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

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 filtragem. Precisa de fornecer pelo menos um identificador. Forneça todos os identificadores estáveis e de confiança que representem um limite de isolamento pretendido.

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

Utilize um cliente Redis gerido pelo chamador

Forneça redis_client quando a sua aplicação precisar de partilhar um conjunto de ligações ou configurar o comportamento da ligação, como tempos limite definidos e verificações do estado de funcionamento. O cliente deve ser um cliente Redis assíncrono autónomo 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 usa o cliente e não o fecha, pelo que a aplicação continua responsável pelo seu ciclo de vida. O comportamento de retentativa também permanece controlado pelo chamador. Os acrescentos à transcrição não são idempotentes se uma nova tentativa repetir uma escrita após uma perda de ligação de resultado ambíguo.

As chaves com âmbito definido são o padrão. Defina um application_id estável e não vazio, e utilize tenant_id e agent_id quando a sua aplicação tiver essas fronteiras de isolamento. O fornecedor também delimita o âmbito de cada chave com base no seu source_id e num ID de sessão não vazio.

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.

As versões anteriores armazenavam o histórico sob {key_prefix}:{session_id or "default"}. As implementações existentes podem definir temporariamente key_format="legacy" durante a migração. O modo legado está obsoleto, não aceita identificadores com escopo, e o modo com escopo nunca lê, reescreve ou elimina chaves legadas. Copie apenas os registos verificados para as chaves do âmbito correspondente, valide o histórico migrado e, em seguida, remova as chaves antigas de acordo com a sua política de retenção.