Redis

Lägg till RAG med TextSearchProvider

Använd det provideroberoende TextSearchProvider mönstret för .NET. Implementera sin sökadapter med Redis-klienten eller vektorlageranslutningen som programmet har valt, mappa Redis-resultaten till TextSearchProvider.TextSearchResult och anslut 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

Sökbar hämtning från minnet fungerar mellan sessioner. Varje angiven application_id, agent_idoch user_id fungerar som ett AND-filter, medan utelämnade dimensioner förblir ofiltrerade. Du måste ange minst en identifierare. Ange varje stabil, betrodd identifierare som representerar en avsedd isoleringsgräns.

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 konversationshistoriken

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

Använda en anroparhanterad Redis-klient

Ange redis_client när ditt program behöver dela en anslutningspool eller konfigurera anslutningsbeteende, till exempel begränsade tidsgränser och hälsokontroller. Klienten måste vara en fristående asynkron Redis-klient som konfigurerats med 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",
)

Kombinera redis_client inte med redis_url eller credential_provider. RedisHistoryProvider lånar klientobjektet och stänger det inte, så applikationen förblir ansvarig för dess livslängd. Återförsöksbeteendet förblir också anropsstyrt. Tillägg till transkript är inte idempotenta om ett nytt försök upprepar en skrivning efter ett oklart anslutningsavbrott.

Nycklar med begränsat omfång är standardvalet. Ange en stabil, icke-tom application_id, och använd tenant_id och agent_id när din applikation har dessa isoleringsgränser. Leverantören avgränsar också varje nyckel utifrån sitt source_id och ett icke-tomt sessions-ID.

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.

Tidigare versioner lagrade historiken under {key_prefix}:{session_id or "default"}. Befintliga driftsättningar kan tillfälligt ange key_format="legacy" under migreringen. Äldre läget är föråldrat, accepterar inte namnrymdsbegränsade identifierare, och namnrymdsläget läser, skriver aldrig om eller tar aldrig bort äldre nycklar. Kopiera endast verifierade poster till motsvarande omfångsnycklar, verifiera den migrerade historiken och ta sedan bort äldre nycklar enligt kvarhållningsprincipen.