Redis

Adicionar RAG com TextSearchProvider

Utilize o padrão TextSearchProvider independente do fornecedor para o .NET. Implemente o respetivo adaptador de pesquisa com o cliente Redis ou o conector de arquivo vetorial selecionado pela sua aplicação, mapeie os resultados do Redis para TextSearchProvider.TextSearchResult e associe 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.
• Fornecedor de incorporação ao ativar 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",
)

Associar memória a um agente

Adicionar o fornecedor a context_providers. O fornecedor armazena detalhes da conversa após uma execução e apresenta o contexto relevante antes das execuções seguintes.

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

Guardar histórico da conversa

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

Pré-requisitos

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

Anexe RedisHistoryProvider até context_providers. 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.