Redis

Agregar RAG con TextSearchProvider

Use el patrón independiente TextSearchProvider del proveedor para .NET. Implemente su adaptador de búsqueda con el cliente de Redis o el conector de almacén vectorial que haya seleccionado su aplicación, asigne los resultados de Redis a TextSearchProvider.TextSearchResult y adjunte el proveedor mediante AIContextProviders.

Este enfoque es compatible con RAG basado en Redis sin requerir un paquete de proveedor de contexto de Agent Framework específico para Redis.

Instalar el paquete

pip install agent-framework-redis --pre

Añadir memoria con capacidad de búsqueda

Use este patrón cuando un agente debe recuperar la información pertinente seleccionada en lugar de reproducir todos los mensajes anteriores.

Prerequisites

• Una implementación de Redis con compatibilidad con RediSearch, como Redis Stack o un servicio administrado compatible.
• Un proyecto y una implementación de modelos de Microsoft Foundry para el agente de ejemplo.
• Un proveedor de incrustaciones cuando habilitas la búsqueda vectorial híbrida.

Configurar memoria de búsqueda

La recuperación de memoria con búsqueda funciona entre sesiones. Cada elemento proporcionado application_id, agent_idy user_id actúa como filtro AND, mientras que las dimensiones omitidas permanecen sin filtrar. Debe proporcionar al menos un identificador. Proporcione cada identificador estable de confianza que represente un límite de aislamiento previsto.

Agregue un vectorizador de Redis y una configuración de campo vectorial cuando desee la recuperación 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",
)

Asignar memoria a un agente

Agregue el proveedor a context_providers. El proveedor almacena los detalles de la conversación después de una ejecución y presenta el contexto pertinente antes de ejecuciones 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)

Conservar el historial de conversaciones

Use este patrón cuando una sesión debe recuperar su transcripción completa después de reiniciar una aplicación o en otra instancia.

Prerequisites

• Una implementación de Redis accesible a través de REDIS_URL.
• TLS y usuarios autenticados de Redis para implementaciones de producción.

Adjunte RedisHistoryProvider hasta context_providers. El proveedor almacena mensajes para la sesión y puede limitar el recuento de mensajes retenidos.

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

Uso de un cliente de Redis administrado por el autor de la llamada

Proporcione redis_client cuando la aplicación necesite compartir un grupo de conexiones o configurar el comportamiento de conexión, como los tiempos de espera limitados y las comprobaciones de estado. El cliente debe ser un cliente asincrónico independiente de Redis configurado con 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",
)

No se combine redis_client con redis_url ni credential_provider. RedisHistoryProvider toma prestado el cliente y no lo cierra, por lo que la aplicación sigue siendo responsable de su duración. El comportamiento de reintento también sigue estando bajo el control de quien realiza la llamada. Los anexos de transcripción no son idempotentes si un reintento reproduce una escritura después de una pérdida ambigua de conexión.

Las claves de ámbito limitado son la opción predeterminada. Establezca un valor estable, no vacío application_idy use tenant_id y agent_id cuando la aplicación tenga esos límites de aislamiento. El proveedor también delimita cada clave por su source_id y un identificador de sesión no vacío.

Use un identificador de sesión estable y conserve el serializado AgentSession en el almacenamiento de aplicaciones de confianza cuando los clientes deben reanudar la misma conversación lógica después de reiniciar un proceso.

Las versiones anteriores almacenaban el historial en {key_prefix}:{session_id or "default"}. Los despliegues existentes pueden establecer temporalmente key_format="legacy" durante la migración. El modo heredado está obsoleto, no acepta identificadores con ámbito, y el modo con ámbito nunca lee, reescribe ni elimina claves heredadas. Copie solo los registros comprobados en las claves con ámbito correspondientes, valide el historial migrado y, a continuación, quite las claves heredadas según la directiva de retención.