Redis

O Redis suporta diferentes padrões de contexto entre SDKs. No .NET, liga a pesquisa apoiada por Redis ao genérico TextSearchProvider para RAG. O pacote Agent Framework Redis fornece fornecedores de memória pesquisável e histórico de conversas para Python.

Pattern API SDK Comportamento
RAG TextSearchProvider com um adaptador de pesquisa Redis .NET Recupera conteúdo relevante do Redis antes da invocação ou através de uma ferramenta de pesquisa sob demanda.
Memória pesquisável RedisContextProvider Python Extrai detalhes conversacionais e recupera contexto relevante com pesquisa vetorial em texto completo ou híbrida.
Histórico de conversações RedisHistoryProvider Python Persiste e recarrega a transcrição exata da mensagem de uma sessão.

Adicionar RAG com TextSearchProvider

Use o padrão independente TextSearchProvider do fornecedor para .NET. Implemente o seu adaptador de pesquisa com o cliente Redis ou conector vector-store selecionado pela sua aplicação, mapeie os resultados do Redis para TextSearchProvider.TextSearchResult, e anexe o fornecedor através de AIContextProviders.

Esta abordagem suporta RAG suportado por Redis, sem exigir um pacote de fornecedor de contexto específico para o Agent Framework de Redis.

Instale o pacote

pip install agent-framework-redis --pre

Adicionar memória pesquisável

Utilize este padrão quando um agente deve recordar informações relevantes selecionadas, em vez de repetir todas as mensagens anteriores.

Pré-requisitos

  • Uma implementação Redis com suporte RediSearch, como Redis Stack ou um serviço gerido compatível.
  • Um projeto Microsoft Foundry e implementação de modelos para o agente de exemplo.
  • Um fornecedor de embedding quando ativa a pesquisa vetorial híbrida.

Configurar memória pesquisável

Use application_id, agent_id, e user_id para particionar memórias. Adicione um vetorizador Redis e definições de campo vetorial quando quiser uma recuperação híbrida.

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

Anexar memória a um agente

Adicionar o fornecedor a context_providers. O fornecedor armazena detalhes conversacionais após uma execução e destaca o contexto relevante antes das execuções posteriores.

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

Persistir histórico de conversas

Use este padrão quando uma sessão tiver de recuperar a sua transcrição completa após um reinício da candidatura ou noutra instância.

Pré-requisitos

  • Uma implantação Redis acessível através de REDIS_URL.
  • TLS e utilizadores autenticados do Redis para implementações em produção.

Anexar RedisHistoryProvider através context_providersde . O fornecedor armazena mensagens para a sessão e pode limitar a contagem de mensagens retidas.

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

Use um ID de sessão estável e persista o serializado AgentSession no armazenamento de aplicações de confiança quando os clientes tiverem de retomar a mesma conversa lógica após o reinício do processo.

Observação

A integração Redis context-provider não está atualmente documentada para o Agent Framework Go. Consulte o repositório Agent Framework Go para o estado mais recente.

Considerações sobre a produção

  • Derivar os escopos de tenant, pesquisa, memória e sessão a partir da identidade de aplicação autenticada, não da saída do modelo.
  • Use TLS, autenticação Redis e isolamento de rede.
  • Use prefixos de chave ou implantações separadas onde o isolamento do tenant o exija.
  • Configure persistência, backups, retenção e expulsão para garantir a durabilidade necessária.
  • Tratar a memória recuperada como entrada não confiável e mitigar a injeção indireta de prompts.
  • Rediga conteúdos sensíveis antes de persistir mensagens ou indexar conteúdos pesquisáveis.

Passos seguintes

Use RAG com TextSearchProvider

Mem0

Aprenda como funcionam os fornecedores de contexto

Vai mais fundo:

  • Last updated on