Redis

O Redis dá suporte a diferentes padrões de contexto em SDKs. Em .NET, conecte a pesquisa apoiada por Redis ao genérico TextSearchProvider para RAG. O pacote Redis do Agent Framework fornece provedores de histórico de conversas e memória pesquisáveis para Python.

Pattern API SDK Behavior
RAG TextSearchProvider com um adaptador de pesquisa redis .NET Recupera o conteúdo relevante do Redis antes da invocação ou por meio de uma ferramenta de pesquisa sob demanda.
Memória pesquisável RedisContextProvider Python Extrai detalhes da conversa e recupera o contexto relevante com a pesquisa de vetor híbrido ou de texto completo.
Histórico da conversa RedisHistoryProvider Python Persiste e recarrega a transcrição exata da mensagem para uma sessão.

Adicionar RAG com TextSearchProvider

Use o padrão independente TextSearchProvider do provedor para .NET. Implemente seu adaptador de pesquisa com o cliente Redis ou o conector de repositório de vetores selecionado pelo seu aplicativo, mapeie os resultados do Redis e TextSearchProvider.TextSearchResultanexe o provedor por meio AIContextProvidersde .

Essa abordagem dá suporte ao RAG com suporte redis sem exigir um pacote de provedor de contexto do Agent Framework específico do Redis.

Instalar o pacote

pip install agent-framework-redis --pre

Adicionar memória pesquisável

Use esse padrão quando um agente deve recuperar informações relevantes selecionadas em vez de reproduzir todas as mensagens anteriores.

Pré-requisitos

  • Uma implantação do Redis com suporte do RediSearch, como o Redis Stack ou um serviço gerenciado compatível.
  • Um projeto do Microsoft Foundry e uma implantação de modelo para o agente de exemplo.
  • Um provedor de inserção quando você habilita a pesquisa de vetor híbrido.

Configurar memória pesquisável

Use application_ide agent_idparticione user_id memórias. Adicione um vetor redis e configurações de campo de vetor quando desejar 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

Adicione o provedor a context_providers. O provedor armazena detalhes de conversa após uma execução e apresenta o contexto relevante antes da execução posterior.

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

Manter o histórico de conversas

Use esse padrão quando uma sessão precisar recuperar sua transcrição completa após a reinicialização de um aplicativo ou em outra instância.

Pré-requisitos

  • Uma implantação do Redis acessível por meio REDIS_URLde .
  • TLS e usuários autenticados do Redis para implantações de produção.

Anexar RedisHistoryProvider por .context_providers O provedor 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 uma ID de sessão estável e persista a serializada AgentSession no armazenamento de aplicativos confiáveis quando os clientes devem retomar a mesma conversa lógica após uma reinicialização do processo.

Note

No momento, a integração do provedor de contexto do Redis não está documentada para o Agent Framework Go. Consulte o repositório Agent Framework Go para obter o status mais recente.

Considerações sobre produção

  • Derivar escopos de locatário, pesquisa, memória e sessão da identidade do aplicativo autenticado, não da saída do modelo.
  • Use a autenticação TLS, o Redis e o isolamento de rede.
  • Use prefixos de chave ou implantações separados em que o isolamento do locatário o exija.
  • Configure persistência, backups, retenção e remoção para a durabilidade necessária.
  • Trate a memória recuperada como entrada não confiável e reduza a injeção de prompt indireto.
  • Redigir conteúdo confidencial antes de persistir mensagens ou indexar conteúdo pesquisável.

Próximas Etapas 

Usar o RAG com TextSearchProvider

Mem0

Saiba como funcionam os provedores de contexto

Vá mais fundo:

  • Last updated on