Redis

RAG mit TextSearchProvider hinzufügen

Verwenden Sie das anbieterunabhängige TextSearchProvider Muster für .NET. Implementieren Sie den Suchadapter mit dem von Ihrer Anwendung ausgewählten Redis-Client oder Vektorspeicher-Connector, bilden Sie die Redis-Ergebnisse auf TextSearchProvider.TextSearchResult ab und binden Sie den Anbieter über AIContextProviders an.

Dieser Ansatz unterstützt Redis-unterstützte RAG, ohne dass ein Redis-spezifisches Agent Framework-Kontextanbieterpaket erforderlich ist.

Installiere das Paket

pip install agent-framework-redis --pre

Hinzufügen von durchsuchbarem Arbeitsspeicher

Verwenden Sie dieses Muster, wenn ein Agent ausgewählte relevante Informationen zurückrufen soll, anstatt jede vorherige Nachricht wiederzugeben.

Voraussetzungen

• Eine Redis-Bereitstellung mit RediSearch-Unterstützung, z. B. Redis Stack oder ein kompatibler verwalteter Dienst.
• Ein Microsoft Foundry-Projekt und Modellbereitstellung für den Beispiel-Agent.
• Einbettungsanbieter, wenn Sie die Hybridvektorsuche aktivieren.

Konfigurieren des durchsuchbaren Speichers

Das Abrufen von Erinnerungen funktioniert sitzungsübergreifend. Alle bereitgestellten application_id, agent_idund user_id fungieren als AND-Filter, während ausgelassene Dimensionen nicht gefiltert bleiben. Sie müssen mindestens einen Bezeichner angeben. Geben Sie jeden stabilen, vertrauenswürdigen Bezeichner an, der eine beabsichtigte Isolationsgrenze darstellt.

Fügen Sie einen Redis-Vektorizer und Vektorfeldeinstellungen hinzu, wenn Sie einen Hybridabruf wünschen.

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

Anfügen von Arbeitsspeicher an einen Agent

Fügen Sie den Anbieter zu context_providers hinzu. Der Anbieter speichert nach einem Lauf Details aus Unterhaltungen und stellt vor späteren Läufen relevanten Kontext bereit.

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

Konversationsverlauf beibehalten

Verwenden Sie dieses Muster, wenn eine Sitzung das vollständige Transkript nach einem Neustart der Anwendung oder in einer anderen Instanz wiederherstellen muss.

Voraussetzungen

• Eine Redis-Bereitstellung, die über REDIS_URL erreichbar ist.
• TLS und authentifizierte Redis-Benutzer für Produktivbereitstellungen.

Anhängen RedisHistoryProvider bis context_providers. Der Anbieter speichert Nachrichten für die Sitzung und kann die Anzahl der aufbewahrten Nachrichten einschränken.

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

Verwenden eines vom Anrufer verwalteten Redis-Clients

Geben Sie redis_client an, wenn Ihre Anwendung einen Verbindungspool gemeinsam nutzen oder das Verbindungsverhalten konfigurieren muss, z. B. begrenzte Timeouts und Zustandsprüfungen. Der Client muss ein eigenständiger asynchroner Redis-Client sein, der mit decode_responses=True konfiguriert ist.

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

Kombinieren Sie nicht redis_client mit redis_url oder credential_provider. RedisHistoryProvider leiht sich den Client aus und schließt ihn nicht, sodass die Anwendung für die Lebensdauer des Clients verantwortlich bleibt. Auch das Wiederholungsverhalten bleibt vom Aufrufer gesteuert. Das Anhängen an ein Transkript ist nicht idempotent, wenn ein Wiederholungsversuch nach einem unklaren Verbindungsabbruch einen Schreibvorgang erneut ausführt.

Bereichsbezogene Schlüssel sind der Standard. Legen Sie ein stabiles, nicht leeres application_id fest und verwenden Sie tenant_id und agent_id, wenn Ihre Anwendung über diese Isolationsgrenzen verfügt. Der Anbieter grenzt außerdem jeden Schlüssel über sein source_id und eine nicht leere Sitzungs-ID ein.

Verwenden Sie eine stabile Sitzungs-ID und speichern Sie die serialisierte Darstellung AgentSession im vertrauenswürdigen Anwendungsspeicher, wenn Clients dieselbe logische Konversation nach einem Prozessneustart fortsetzen müssen.

Frühere Versionen speicherten den Verlauf unter {key_prefix}:{session_id or "default"}. Bestehende Bereitstellungen können während der Migration vorübergehend key_format="legacy" festlegen. Der Legacy-Modus ist als veraltet markiert, akzeptiert keine bereichsbezogenen Kennungen, und der Scoped-Modus liest, überschreibt oder löscht niemals Legacy-Schlüssel. Kopieren Sie nur verifizierte Datensätze in die entsprechenden bereichsspezifischen Schlüssel, validieren Sie den migrierten Verlauf und entfernen Sie dann Legacy-Schlüssel gemäß Ihrer Aufbewahrungsrichtlinie.