Redis

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

Het ophalen van doorzoekbaar geheugen werkt over sessies heen. Elke opgegeven application_id, agent_iden user_id fungeert als een AND-filter, terwijl weggelaten dimensies ongefilterd blijven. U moet ten minste één id opgeven. Geef elke stabiele, vertrouwde id op die een beoogde isolatiegrens vertegenwoordigt.

Voeg een Redis-vectorizer en instellingen voor vectorvelden toe wanneer u hybride zoekopdrachten 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,
        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}")

Een door een beller beheerde Redis-client gebruiken

Geef redis_client op wanneer uw toepassing een verbindingsgroep moet delen of verbindingsgedrag moet configureren, zoals gebonden time-outs en statuscontroles. De client moet een zelfstandige asynchrone Redis-client zijn die is geconfigureerd met 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",
)

Combineer niet redis_client met redis_url of credential_provider. RedisHistoryProvider gebruikt de client en sluit deze niet, waardoor de toepassing verantwoordelijk blijft voor de levensduur ervan. Het herhalingsgedrag wordt ook nog steeds door de aanroeper bepaald. Toevoegingen aan het transcript zijn niet idempotent als een nieuwe poging een schrijfactie opnieuw uitvoert na een onduidelijk verbindingsverlies.

Sleutels met een bereik zijn de standaard. Stel een stabiele, lege application_idwaarde in en gebruik tenant_id en agent_id wanneer uw toepassing deze isolatiegrenzen heeft. De provider bakent elke sleutel ook af op basis van de source_id en een niet-lege sessie-id.

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.

Eerdere releases sloegen de geschiedenis op onder {key_prefix}:{session_id or "default"}. Bestaande implementaties kunnen tijdens de migratie tijdelijk op key_format="legacy" worden ingesteld. Legacy-modus is verouderd, accepteert geen scoped identifiers, en de scoped-modus leest, herschrijft of verwijdert nooit legacy-sleutels. Kopieer alleen geverifieerde records naar de bijbehorende bereiksleutels, valideer de gemigreerde geschiedenis en verwijder verouderde sleutels op basis van uw bewaarbeleid.