Redis

Ajouter RAG avec TextSearchProvider

Utilisez le modèle indépendant TextSearchProvider du fournisseur pour .NET. Implémentez son adaptateur de recherche avec le client Redis ou le connecteur de base de données vectorielle sélectionné par votre application, mappez les résultats Redis sur TextSearchProvider.TextSearchResult, et associez le fournisseur via AIContextProviders.

Cette approche prend en charge le RAG adossé à Redis sans nécessiter de package de fournisseur de contexte pour Agent Framework spécifique à Redis.

Installer le package

pip install agent-framework-redis --pre

Ajouter une mémoire pouvant faire l’objet d’une recherche

Utilisez ce modèle lorsqu’un agent doit rappeler les informations pertinentes sélectionnées plutôt que de relire chaque message précédent.

Prerequisites

• Un déploiement Redis avec prise en charge de RediSearch, tel que Redis Stack ou un service managé compatible.
• Un projet Microsoft Foundry et un déploiement d’un modèle pour l’agent d’exemple.
• Fournisseur d’incorporation lorsque vous activez la recherche vectorielle hybride.

Configurer la mémoire pouvant faire l’objet d’une recherche

La recherche dans la mémoire fonctionne d’une session à l’autre. Chacun des application_id, agent_id et user_id fournis agit comme un filtre ET, tandis que les dimensions omises restent non filtrées. Vous devez fournir au moins un identificateur. Fournissez chaque identificateur stable et approuvé qui représente une limite d’isolation prévue.

Ajoutez un vectoris Redis et des paramètres de champ vectoriel lorsque vous souhaitez une récupération hybride.

# Create a provider with partition scope and OpenAI embeddings

# Please set OPENAI_API_KEY to use the OpenAI vectorizer.
# For chat responses, also set FOUNDRY_PROJECT_ENDPOINT and FOUNDRY_MODEL.

# We attach an embedding vectorizer so the provider can perform hybrid (text + vector)
# retrieval. If you prefer text-only retrieval, instantiate RedisContextProvider without the
# 'vectorizer' and vector_* parameters.
vectorizer = OpenAITextVectorizer(
    model="text-embedding-ada-002",
    api_config={"api_key": os.getenv("OPENAI_API_KEY")},
    cache=EmbeddingsCache(name="openai_embeddings_cache", redis_url=REDIS_URL),
)
# The provider manages persistence and retrieval. application_id/agent_id/user_id
# scope data for multi-tenant separation; thread_id (set later) narrows to a
# specific conversation.
provider = RedisContextProvider(
    source_id="redis_context",
    redis_url=REDIS_URL,
    index_name="redis_basics",
    application_id="matrix_of_kermits",
    agent_id="agent_kermit",
    user_id="kermit",
    redis_vectorizer=vectorizer,
    vector_field_name="vector",
    vector_algorithm="hnsw",
    vector_distance_metric="cosine",
)

Attacher de la mémoire à un assistant

Ajoutez le fournisseur à context_providers. Le fournisseur stocke les détails conversationnels après une exécution et affiche le contexte pertinent avant les exécutions ultérieures.

# Create chat client for the agent
client = create_chat_client()
# Create agent wired to the Redis context provider. The provider automatically
# persists conversational details and surfaces relevant context on each turn.
agent = Agent(
    client=client,
    name="MemoryEnhancedAssistant",
    instructions=(
        "You are a helpful assistant. Personalize replies using provided context. "
        "Before answering, always check for stored context"
    ),
    tools=[],
    context_providers=[provider],
)

# Teach a user preference; the agent writes this to the provider's memory
query = "Remember that I enjoy glugenflorgle"
result = await agent.run(query)
print("User: ", query)
print("Agent: ", result)

# Ask the agent to recall the stored preference; it should retrieve from memory
query = "What do I enjoy?"
result = await agent.run(query)

Conserver l’historique des conversations

Utilisez ce modèle lorsqu’une session doit récupérer sa transcription complète après un redémarrage d’une application ou sur une autre instance.

Prerequisites

• Un déploiement Redis accessible via REDIS_URL.
• TLS et utilisateurs Redis authentifiés pour les déploiements en production.

Attachez RedisHistoryProvider à travers context_providers. Le fournisseur stocke les messages de la session et peut limiter le nombre de messages conservés.

async def example_manual_memory_store() -> None:
    """Basic example of using Redis history provider."""
    print("=== Basic Redis History Provider Example ===")

    # Create Redis history provider
    redis_provider = RedisHistoryProvider(
        source_id="redis_basic_chat",
        redis_url=REDIS_URL,
        application_id=APPLICATION_ID,
        agent_id="redis-bot",
    )

    # Create agent with Redis history provider
    agent = Agent(
        client=OpenAIChatClient(),
        name="RedisBot",
        instructions="You are a helpful assistant that remembers our conversation using Redis.",
        context_providers=[redis_provider],
    )

    # Create session
    session = agent.create_session()

    # Have a conversation
    print("\n--- Starting conversation ---")
    query1 = "Hello! My name is Alice and I love pizza."
    print(f"User: {query1}")
    response1 = await agent.run(query1, session=session)
    print(f"Agent: {response1.text}")

    query2 = "What do you remember about me?"
    print(f"User: {query2}")

Utiliser un client Redis géré par l’appelant

Indiquez redis_client quand votre application doit partager un pool de connexions ou configurer un comportement de connexion tel que des délais d’attente limités et des vérifications d’intégrité. Le client doit être un client Redis asynchrone autonome configuré avec decode_responses=True.

from agent_framework.redis import RedisHistoryProvider
from redis.asyncio import Redis

redis_client = Redis.from_url(
    "redis://localhost:6379",
    decode_responses=True,
    socket_connect_timeout=3,
    socket_timeout=5,
)

history_provider = RedisHistoryProvider(
    redis_client=redis_client,
    application_id="support-app",
)

Ne pas combiner redis_client avec redis_url ou credential_provider. RedisHistoryProvider utilise le client fourni et ne le ferme pas ; l’application reste donc responsable de son cycle de vie. Le comportement de nouvelle tentative reste également contrôlé par l’appelant. Les ajouts à la transcription ne sont pas idempotents si une nouvelle tentative rejoue une écriture après une perte de connexion dont les conséquences sont ambiguës.

Les clés délimitées sont la valeur par défaut. Définissez un application_id stable et non vide, et utilisez tenant_id et agent_id lorsque votre application comporte ces limites d’isolation. Le fournisseur associe également chaque clé à son source_id et à un identifiant de session non vide.

Utilisez un ID de session stable et conservez le sérialisé AgentSession dans le stockage d’applications approuvés lorsque les clients doivent reprendre la même conversation logique après un redémarrage du processus.

Les versions antérieures stockaient l’historique sous {key_prefix}:{session_id or "default"}. Les déploiements existants peuvent temporairement définir key_format="legacy" pendant la migration. Le mode hérité est déconseillé, n’accepte pas d’identificateurs délimités et le mode délimité ne lit jamais, réécrit ou supprime les clés héritées. Copiez uniquement les enregistrements vérifiés dans les clés délimitées correspondantes, validez l’historique migré, puis supprimez les clés héritées en fonction de votre stratégie de rétention.