Redis

Adicionar RAG com TextSearchProvider

Use o padrão TextSearchProvider independente de provedor para .NET. Implemente seu adaptador de pesquisa com o cliente Redis ou o conector de armazenamento vetorial selecionados pelo seu aplicativo, mapeie os resultados do Redis para TextSearchProvider.TextSearchResult e anexe o provedor por meio de AIContextProviders.

Essa abordagem oferece suporte a RAG baseado em Redis sem exigir um pacote de provedor de contexto do Agent Framework específico para 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.

Prerequisites

• 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 embeddings quando você habilita a busca vetorial híbrida.

Configurar memória pesquisável

A recuperação de memória pesquisável funciona entre sessões. Cada application_id, agent_id e user_id fornecido funciona como um filtro AND, enquanto as dimensões omitidas permanecem sem filtro. Você precisa fornecer pelo menos um identificador. Forneça cada identificador estável e confiável que represente um limite de isolamento pretendido.

Adicione um vetorizador Redis e configurações de campo vetorial quando quiser 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",
)

Anexe 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.

Prerequisites

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

Anexe RedisHistoryProvider até 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,
        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}")

Use um cliente Redis controlado pelo chamador

Forneça redis_client quando seu aplicativo precisar compartilhar um pool de conexões ou configurar o comportamento de conexão, como tempos limite limitados e verificações de integridade. O cliente deve ser um cliente autônomo do Redis assíncrono configurado com 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",
)

Não combine redis_client com redis_url ou credential_provider. RedisHistoryProvider empresta o cliente e não o fecha, portanto o aplicativo permanece responsável por todo o seu tempo de vida. O comportamento de repetição também permanece controlado pelo chamador. As anexações de transcrição não são idempotentes se uma nova tentativa reproduzir uma gravação após uma perda de conexão ambígua.

Chaves com escopo são o padrão. Defina um valor estável e não vazio para application_id e use tenant_id e agent_id quando seu aplicativo tiver essas fronteiras de isolamento. O provedor também delimita o escopo de cada chave por seu source_id e um ID de sessão não vazio.

Use uma ID de sessão estável e persista o AgentSession serializado em um armazenamento confiável do aplicativo quando os clientes precisarem retomar a mesma conversa lógica após um reinício do processo.

Versões anteriores armazenavam o histórico em {key_prefix}:{session_id or "default"}. As implantações existentes podem ser configuradas temporariamente como key_format="legacy" durante a migração. O modo legado é obsoleto, não aceita identificadores com escopo, e o modo com escopo nunca lê, reescreve nem exclui chaves legadas. Copie apenas os registros verificados nas chaves de escopo correspondentes, valide o histórico migrado e remova as chaves herdadas de acordo com sua política de retenção.