Redis

Redis supporta modelli di contesto diversi tra GLI SDK. In .NET connettere la ricerca supportata da Redis al generico TextSearchProvider per rag. Il pacchetto Redis di Agent Framework fornisce provider di memoria e cronologia conversazioni ricercabili per Python.

Pattern API SDK Behavior
STRACCIO TextSearchProvider con un adattatore di ricerca Redis .NET Recupera il contenuto Redis pertinente prima della chiamata o tramite uno strumento di ricerca su richiesta.
Memoria ricercabile RedisContextProvider Python Estrae i dettagli della conversazione e recupera il contesto pertinente con la ricerca full-text o vettoriale ibrida.
Cronologia della conversazione RedisHistoryProvider Python Rende persistente e ricarica la trascrizione esatta del messaggio per una sessione.

Aggiungere RAG con TextSearchProvider

Usare il modello indipendente TextSearchProvider dal provider per .NET. Implementare l'adattatore di ricerca con il client Redis o il connettore vector-store selezionato dall'applicazione, eseguire il mapping dei risultati di Redis a TextSearchProvider.TextSearchResulte collegare il provider tramite AIContextProviders.

Questo approccio supporta la funzionalità RAG supportata da Redis senza richiedere un pacchetto del provider di contesto del framework agente specifico di Redis.

Installare il pacchetto

pip install agent-framework-redis --pre

Aggiungere memoria ricercabile

Usare questo modello quando un agente deve richiamare le informazioni pertinenti selezionate anziché riprodurre ogni messaggio precedente.

Prerequisiti

  • Una distribuzione Redis con supporto RediSearch, ad esempio Stack Redis o un servizio gestito compatibile.
  • Un progetto foundry Microsoft e la distribuzione del modello per l'agente di esempio.
  • Provider di incorporamento quando si abilita la ricerca vettoriale ibrida.

Configurare la memoria ricercabile

Usare application_id, agent_ide user_id per partizionare i ricordi. Aggiungere un vettore Redis e le impostazioni del campo vettoriale quando si vuole il recupero ibrido.

# 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",
)

Collegare memoria a un agente

Aggiungere il provider a context_providers. Il provider archivia i dettagli della conversazione dopo un'esecuzione e presenta il contesto pertinente prima dell'esecuzione successiva.

# 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)

Rendere persistente la cronologia delle conversazioni

Usare questo modello quando una sessione deve recuperare la trascrizione completa dopo il riavvio di un'applicazione o in un'altra istanza.

Prerequisiti

  • Una distribuzione Redis raggiungibile tramite REDIS_URL.
  • Utenti di TLS e Redis autenticati per le distribuzioni di produzione.

Allegare RedisHistoryProvider tramite context_providers. Il provider archivia i messaggi per la sessione e può limitare il numero di messaggi conservati.

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}")

Usare un ID sessione stabile e rendere persistente il serializzato AgentSession nell'archiviazione di applicazioni attendibili quando i client devono riprendere la stessa conversazione logica dopo il riavvio di un processo.

Annotazioni

L'integrazione del provider di contesto Redis non è attualmente documentata per Agent Framework Go. Vedere il repository di Agent Framework Go per lo stato più aggiornato.

Considerazioni sulla produzione

  • Derivare gli ambiti tenant, ricerca, memoria e sessione dall'identità dell'applicazione autenticata, non dall'output del modello.
  • Usare TLS, l'autenticazione Redis e l'isolamento della rete.
  • Usare prefissi di chiave separati o distribuzioni in cui è necessario l'isolamento del tenant.
  • Configurare la persistenza, i backup, la conservazione e la rimozione per la durabilità necessaria.
  • Considerare la memoria recuperata come input non attendibile e attenuare l'inserimento indiretto delle richieste.
  • Redact sensitive content before persisting messages or indexing searchable content.Redact sensitive content before persisting messages or indexing searchable content.

Passaggi successivi

Usare RAG con TextSearchProvider

Mem0

Informazioni sul funzionamento dei provider di contesto

Approfondimento:

  • Last updated on