Redis

Hinzufügen von RAG mit TextSearchProvider

Verwenden Sie das anbieterunabhängige TextSearchProvider Muster für .NET. Implementieren Sie den Suchadapter mit dem Redis-Client- oder Vektorspeicher-Connector, der von Ihrer Anwendung ausgewählt wurde, ordnen Sie die Redis-Ergebnisse zu TextSearchProvider.TextSearchResult, und fügen Sie den Anbieter über AIContextProviders.

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

Verwenden Sie application_id, agent_idund user_id partitionieren Sie Erinnerungen. 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. Der Anbieter speichert unterhaltungsbezogene Details nach einer Ausführung und zeigt relevanten Kontext vor der späteren Ausführung an.

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

Aufgezeichnete Unterhaltungen 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 kann durch erreicht werden REDIS_URL.
• TLS- und authentifizierte Redis-Benutzer für Produktionsbereitstellungen.

Anfügen RedisHistoryProvider über 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,
    )

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

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