Redis

Redis ondersteunt verschillende contextpatronen in SDK's. In .NET verbindt u met Redis ondersteunde zoekopdrachten naar het algemeen TextSearchProvider voor RAG. Het Agent Framework Redis-pakket biedt doorzoekbare geheugen- en gespreksgeschiedenisproviders voor Python.

Pattern API SDK Gedrag
RAG TextSearchProvider met een Redis-zoekadapter .NET Hiermee haalt u relevante Redis-inhoud op voordat u een aanroep of via een zoekprogramma op aanvraag uitvoert.
Doorzoekbaar geheugen RedisContextProvider Python Haalt gespreksdetails op en haalt relevante context op met zoeken in volledige tekst of hybride vectoren.
Gespreksgeschiedenis RedisHistoryProvider Python Hiermee blijft de exacte berichttranscriptie voor een sessie behouden en opnieuw geladen.

RAG toevoegen met TextSearchProvider

Gebruik het provideronafhankelijke TextSearchProvider patroon voor .NET. Implementeer de zoekadapter met de Redis-client of vector-store-connector die door uw toepassing is geselecteerd, wijs de Redis-resultaten toe aan TextSearchProvider.TextSearchResulten koppel de provider via AIContextProviders.

Deze benadering ondersteunt door Redis ondersteunde RAG zonder dat hiervoor een redis-specifiek Agent Framework-contextproviderpakket nodig is.

Installeer het pakket

pip install agent-framework-redis --pre

Doorzoekbaar geheugen toevoegen

Gebruik dit patroon wanneer een agent relevante informatie moet intrekken in plaats van elk vorig bericht opnieuw af te spelen.

Prerequisites

  • Een Redis-implementatie met RediSearch-ondersteuning, zoals Redis Stack of een compatibele beheerde service.
  • Een Microsoft Foundry-project en modelimplementatie voor de voorbeeldagent.
  • Een insluitprovider wanneer u hybride vectorzoekopdrachten inschakelt.

Doorzoekbaar geheugen configureren

Gebruik application_id, agent_iden user_id om herinneringen te partitioneren. Voeg een Redis vectorizer en vectorveldinstellingen toe wanneer u hybride ophalen wilt.

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

Geheugen koppelen aan een agent

Voeg de provider toe aan context_providers. De provider slaat gespreksdetails op na een uitvoering en geeft relevante context weer voordat deze later wordt uitgevoerd.

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

Gespreksgeschiedenis behouden

Gebruik dit patroon wanneer een sessie het volledige transcript moet herstellen nadat een toepassing opnieuw is opgestart of op een ander exemplaar.

Prerequisites

  • Een Redis-implementatie bereikbaar via REDIS_URL.
  • TLS en geverifieerde Redis-gebruikers voor productie-implementaties.

Bijvoegen RedisHistoryProvider via context_providers. De provider slaat berichten voor de sessie op en kan het aantal bewaarde berichten beperken.

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

Gebruik een stabiele sessie-id en bewaar de geserialiseerde AgentSession in vertrouwde toepassingsopslag wanneer clients hetzelfde logische gesprek moeten hervatten nadat een proces opnieuw is opgestart.

Opmerking

Integratie van Redis-contextproviders wordt momenteel niet gedocumenteerd voor Agent Framework Go. Zie de opslagplaats Agent Framework Go voor de meest recente status.

Overwegingen voor productie

  • Tenant-, zoek-, geheugen- en sessiebereiken afleiden uit geverifieerde toepassingsidentiteit, niet modeluitvoer.
  • Gebruik TLS- en Redis-verificatie en netwerkisolatie.
  • Gebruik afzonderlijke sleutelvoorvoegsels of implementaties waarvoor tenantisolatie is vereist.
  • Configureer persistentie, back-ups, retentie en verwijdering voor de vereiste duurzaamheid.
  • Behandel het opgehaalde geheugen als niet-vertrouwde invoer en beperk indirecte promptinjectie.
  • Gevoelige inhoud redacteren voordat berichten worden bewaard of doorzoekbare inhoud wordt geïndexeerde.

Volgende stappen 

RAG gebruiken met TextSearchProvider

Mem0

Meer informatie over hoe contextproviders werken

Ga dieper in:

  • Last updated on