Redis

Redis stöder olika kontextmönster mellan SDK:er. I .NET ansluter du Redis-säkerhetskopierad sökning till den generiska TextSearchProvider för RAG. Agent Framework Redis-paketet tillhandahåller sökbara minnes- och konversationshistorikprovidrar för Python.

Pattern API SDK Behavior
LUMP TextSearchProvider med ett Redis-sökkort .NET Hämtar relevant Redis-innehåll före anrop eller via ett sökverktyg på begäran.
Sökbart minne RedisContextProvider Python Extraherar konversationsinformation och hämtar relevant kontext med fulltext- eller hybridvektorsökning.
Konversationshistorik RedisHistoryProvider Python Bevarar och läser in den exakta meddelandeavskriften för en session igen.

Lägg till RAG med TextSearchProvider

Använd det provideroberoende TextSearchProvider mönstret för .NET. Implementera dess sökkort med Redis-klienten eller vektorlagringsanslutningen som valts av ditt program, mappa Redis-resultatet till TextSearchProvider.TextSearchResultoch koppla providern via AIContextProviders.

Den här metoden stöder Redis-backad RAG utan att kräva ett Redis-specifikt Agent Framework-paket för kontextprovider.

Installera paketet

pip install agent-framework-redis --pre

Lägga till sökbart minne

Använd det här mönstret när en agent bör återkalla vald relevant information i stället för att spela upp varje tidigare meddelande.

Förutsättningar

  • En Redis-distribution med Stöd för RediSearch, till exempel Redis Stack eller en kompatibel hanterad tjänst.
  • Ett Microsoft Foundry-projekt och modelldistribution för exempelagenten.
  • En inbäddningsprovider när du aktiverar hybridvektorsökning.

Konfigurera sökbart minne

Använd application_id, agent_idoch user_id för att partitioneringsminnen. Lägg till en Redis-vektoriserare och vektorfältsinställningar när du vill hämta hybrider.

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

Koppla minne till en agent

Lägg till providern i context_providers. Providern lagrar konversationsinformation efter en körning och visar relevant kontext innan senare körningar.

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

Spara konversationshistorik

Använd det här mönstret när en session måste återställa sin fullständiga avskrift efter en omstart av ett program eller på en annan instans.

Förutsättningar

  • En Redis-distribution kan nås via REDIS_URL.
  • TLS och autentiserade Redis-användare för produktionsdistributioner.

Koppla RedisHistoryProvider genom context_providers. Providern lagrar meddelanden för sessionen och kan begränsa antalet kvarhållna meddelanden.

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

Använd ett stabilt sessions-ID och spara det serialiserade AgentSession i betrott programlagring när klienter måste återuppta samma logiska konversation efter en omstart av processen.

Anmärkning

Integreringen av Redis-kontextprovidern är för närvarande inte dokumenterad för Agent Framework Go. Se Agent Framework Go-lagringsplatsen för den senaste statusen.

Produktionsöverväganden

  • Härled klient-, sök-, minnes- och sessionsomfattningar från autentiserad programidentitet, inte modellutdata.
  • Använd TLS, Redis-autentisering och nätverksisolering.
  • Använd separata nyckelprefix eller distributioner där klientisolering kräver det.
  • Konfigurera beständighet, säkerhetskopior, kvarhållning och borttagning för den hållbarhet som krävs.
  • Behandla hämtat minne som ej betrodda indata och minimera indirekt promptinmatning.
  • Redigera känsligt innehåll innan du bevarar meddelanden eller indexerar sökbart innehåll.

Nästa steg

Använda RAG med TextSearchProvider

Mem0

Lär dig hur kontextleverantörer fungerar

Gå djupare:

  • Last updated on