Redis

Redis podporuje různé kontextové vzory napříč sadami SDK. V .NET připojte vyhledávání postavené na Redisu k obecnému TextSearchProvider pro RAG. Balíček Agent Framework Redis poskytuje prohledávatelnou paměť a poskytovatele historie konverzací pro Python.

Vzor API sada SDK Behavior
HADR TextSearchProvider s vyhledávacím adaptérem Redis platforma .NET Načte relevantní obsah Redis před vyvoláním nebo prostřednictvím vyhledávacího nástroje na vyžádání.
Prohledávatelná paměť RedisContextProvider Python Extrahuje konverzační podrobnosti a načte relevantní kontext pomocí fulltextového nebo hybridního vektorového vyhledávání.
Historie konverzací RedisHistoryProvider Python Uloží a znovu načte přesný záznam konverzace pro danou relaci.

Přidejte RAG pomocí TextSearchProvider

Pro .NET použijte model nezávislý TextSearchProvider na poskytovateli. Implementujte jeho vyhledávací adaptér s klientem Redis nebo konektorem pro vektorové úložiště vybraným vaší aplikací, namapujte výsledky Redis na TextSearchProvider.TextSearchResulta připojte poskytovatele prostřednictvím AIContextProviders.

Tento přístup podporuje RAG využívající Redis bez nutnosti balíčku poskytovatele kontextu pro Agent Framework specifického pro Redis.

Nainstalujte balíček

pip install agent-framework-redis --pre

Přidání prohledávatelné paměti

Tento vzor použijte, když by měl agent odvolat vybrané relevantní informace, a ne přehrát každou předchozí zprávu.

Prerequisites

  • Nasazení Redis s podporou RediSearch, jako je Redis Stack nebo kompatibilní spravovaná služba.
  • Projekt Microsoft Foundry a nasazení modelu pro ukázkového agenta.
  • Zprostředkovatel vkládání, když povolíte hybridní vektorové vyhledávání.

Konfigurace prohledávatelné paměti

Prohledávatelné načítání paměti funguje napříč relacemi. Každý zadaný application_id, agent_ida user_id funguje jako filtr AND, zatímco vynechané dimenze zůstávají nefiltrované. Musíte zadat alespoň jeden identifikátor. Zadejte každý stabilní důvěryhodný identifikátor, který představuje zamýšlenou hranici izolace.

Pokud chcete hybridní načtení, přidejte vektorizátor Redis a nastavení vektorového pole.

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

Připojte paměť k agentovi

Přidejte poskytovatele do context_providers. Poskytovatel ukládá konverzační podrobnosti po spuštění a zobrazí relevantní kontext před pozdějším spuštěním.

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

Zachování historie konverzací

Tento vzor použijte, když relace musí po restartu aplikace nebo na jiné instanci obnovit celý přepis.

Prerequisites

  • Nasazení Redis je dostupné prostřednictvím REDIS_URL.
  • TLS a ověřování uživatelů Redisu pro produkční nasazení

Připojte RedisHistoryProvider ke context_providers. Poskytovatel ukládá zprávy pro relaci a může omezit počet zachovaných zpráv.


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

Použití klienta Redis spravovaného volajícím

Zadejte redis_client , když vaše aplikace potřebuje sdílet fond připojení nebo nakonfigurovat chování připojení, jako jsou omezené časové limity a kontroly stavu. Klient musí být samostatný asynchronní klient Redis nakonfigurovaný pomocí 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",
)

Nekombinujte redis_client s redis_url ani credential_provider. RedisHistoryProvider převezme klienta a neuzavře ho, takže aplikace zůstává odpovědná za jeho životnost. Mechanismus opakování také zůstává pod kontrolou volajícího. Připojení k transkriptu nejsou idempotentní, pokud opakovaný pokus po nejednoznačném výpadku připojení znovu provede zápis.

Klíče s vymezeným oborem jsou výchozí. Nastavte stabilní, neprázdné application_ida používejte tenant_id a agent_id pokud má vaše aplikace tyto hranice izolace. Poskytovatel také rozlišuje každý klíč podle jeho source_id a neprázdného ID relace.

Použijte stabilní ID relace a serializovanou podobu AgentSession trvale uchovávejte v důvěryhodném úložišti aplikace, pokud klienti musí po restartu procesu navázat na stejnou logickou konverzaci.

Dřívější verze ukládaly historii pod {key_prefix}:{session_id or "default"}. Ve stávajících nasazeních lze při migraci dočasně nastavit key_format="legacy". Starší režim je zastaralý, nepřijímá identifikátory s vymezeným oborem a režim s vymezeným oborem nikdy nečte, přepisuje ani neodstraní starší klíče. Zkopírujte jenom ověřené záznamy do odpovídajících klíčů s vymezeným oborem, ověřte migrovanou historii a pak podle zásad uchovávání informací odeberte starší klíče.

Poznámka:

Integrace zprostředkovatele kontextu Redis není aktuálně zdokumentovaná pro Agent Framework Go. Nejnovější stav najdete v úložišti Agent Framework Go .

Důležité informace o produkčním prostředí

  • Odvozujte rozsahy tenanta, vyhledávání, paměti a relací z ověřené identity aplikace, nikoli z výstupu modelu.
  • Používejte protokol TLS, ověřování Redis a izolaci sítě.
  • Pro historii konverzací v Pythonu nastavte rozsahy tenanta, aplikace, agenta, zdroje poskytovatele a relace tam, kde tyto hranice existují.
  • Nakonfigurujte trvalost, zálohy, uchovávání a vyřazení pro požadovanou odolnost.
  • Považujte získanou paměť za nedůvěryhodný vstup a zmírňujte riziko nepřímé injekce promptu.
  • Odstraňte citlivý obsah před uložením zpráv nebo zařazením prohledávatelného obsahu do indexu.

Další kroky

Použijte RAG s TextSearchProvider

Mem0

Zjistěte, jak fungují zprostředkovatelé kontextu.

Jděte hlouběji:

  • Last updated on