Redis

Redis prend en charge différents modèles de contexte entre les kits SDK. Dans .NET, connectez la recherche redis soutenue par Redis au générique TextSearchProvider de RAG. Le package Redis Agent Framework fournit des fournisseurs de mémoire et d’historique des conversations pouvant faire l’objet d’une recherche pour Python.

Pattern API SDK Comportement
RAG TextSearchProvider avec un adaptateur de recherche Redis .NET Récupère le contenu Redis pertinent avant l’appel ou via un outil de recherche à la demande.
Mémoire pouvant faire l’objet d’une recherche RedisContextProvider Python Extrait les détails de conversation et récupère le contexte pertinent avec la recherche de vecteurs hybrides ou en texte intégral.
Historique de la conversation RedisHistoryProvider Python Conserve et recharge la transcription exacte du message pour une session.

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 magasin vectoriel sélectionné par votre application, mappez les résultats Redis et TextSearchProvider.TextSearchResultattachez le fournisseur via AIContextProviders.

Cette approche prend en charge le RAG soutenu par Redis sans nécessiter de package de fournisseur de contexte d’infrastructure d’agent 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 de modèle pour l’exemple d’agent.
  • Fournisseur d’incorporation lorsque vous activez la recherche vectorielle hybride.

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

Utilisez application_id, agent_idet user_id pour partitionner des mémoires. 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 agent

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.
  • Utilisateurs Redis tls et authentifiés pour les déploiements de production.

Attacher RedisHistoryProvider via 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,
    )

    # 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}")
    response2 = await agent.run(query2, session=session)
    print(f"Agent: {response2.text}")

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.

Note

L’intégration du fournisseur de contexte Redis n’est actuellement pas documentée pour Agent Framework Go. Consultez le référentiel Agent Framework Go pour connaître l’état le plus récent.

Considérations relatives à la production

  • Dérivez les étendues du locataire, de la recherche, de la mémoire et de la session à partir de l’identité d’application authentifiée, et non de la sortie du modèle.
  • Utilisez TLS, l’authentification Redis et l’isolation réseau.
  • Utilisez des préfixes ou des déploiements de clés distincts dans lesquels l’isolation du locataire l’exige.
  • Configurez la persistance, les sauvegardes, la rétention et l’éviction pour la durabilité requise.
  • Traitez la mémoire récupérée comme une entrée non approuvée et atténuez l’injection d’invite indirecte.
  • Réactez le contenu sensible avant de conserver des messages ou d’indexer du contenu pouvant faire l’objet d’une recherche.

Étapes suivantes

Utiliser RAG avec TextSearchProvider

Mem0

Découvrez comment fonctionnent les fournisseurs de contexte

Aller plus loin :

  • Last updated on