Redis

Usługa Redis obsługuje różne wzorce kontekstowe w zestawach SDK. W .NET połącz wyszukiwanie oparte na usłudze Redis z ogólną TextSearchProvider bazą danych RAG. Pakiet Redis platformy Agent Framework udostępnia dostawców pamięci i historii konwersacji dla Python z możliwością wyszukiwania.

Pattern API SDK Behavior
RAG TextSearchProvider z kartą wyszukiwania Redis .NET Pobiera odpowiednią zawartość usługi Redis przed wywołaniem lub za pomocą narzędzia wyszukiwania na żądanie.
Pamięć z możliwością wyszukiwania RedisContextProvider Python Wyodrębnia szczegóły konwersacyjne i pobiera odpowiedni kontekst z wyszukiwaniem pełnotekstowym lub hybrydowym.
Historia konwersacji RedisHistoryProvider Python Utrwala i ponownie ładuje dokładną transkrypcję komunikatów dla sesji.

Dodaj element RAG za pomocą polecenia TextSearchProvider

Użyj wzorca niezależnego od TextSearchProvider dostawcy dla .NET. Zaimplementuj kartę wyszukiwania za pomocą klienta usługi Redis lub łącznika magazynu wektorów wybranego przez aplikację, zamapuj wyniki usługi Redis na TextSearchProvider.TextSearchResult, a następnie dołącz dostawcę za pomocą polecenia AIContextProviders.

Takie podejście obsługuje obsługiwaną przez usługę Redis bez konieczności używania pakietu kontekstowego dostawcy platformy agentów specyficznych dla usługi Redis.

Instalowanie pakietu 

pip install agent-framework-redis --pre

Dodawanie pamięci z możliwością wyszukiwania

Użyj tego wzorca, gdy agent powinien odwołać wybrane istotne informacje, zamiast powtarzać co poprzedni komunikat.

Wymagania wstępne

  • Wdrożenie usługi Redis z obsługą usługi RediSearch, takie jak Redis Stack lub zgodna usługa zarządzana.
  • Projekt Microsoft Foundry i wdrożenie modelu dla przykładowego agenta.
  • Dostawca osadzania podczas włączania wyszukiwania wektorów hybrydowych.

Konfigurowanie pamięci z możliwością wyszukiwania

Użyj , application_idagent_idi user_id , aby podzielić pamięci. Dodaj ustawienia wektoryzatora redis i pola wektora, gdy chcesz pobrać hybrydowe.

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

Dołączanie pamięci do agenta

Dodaj dostawcę do context_providers. Dostawca przechowuje konwersacyjne szczegóły po uruchomieniu i wyświetla odpowiedni kontekst przed późniejszym uruchomieniem.

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

Utrwalanie historii konwersacji

Użyj tego wzorca, gdy sesja musi odzyskać kompletną transkrypcję po ponownym uruchomieniu aplikacji lub w innym wystąpieniu.

Wymagania wstępne

  • Wdrożenie usługi Redis osiągalne za pośrednictwem usługi REDIS_URL.
  • Użytkownicy protokołu TLS i uwierzytelnieni użytkownicy usługi Redis na potrzeby wdrożeń produkcyjnych.

Dołącz RedisHistoryProvider za pośrednictwem .context_providers Dostawca przechowuje komunikaty dla sesji i może ograniczyć liczbę zachowanych komunikatów.

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

Użyj stabilnego identyfikatora sesji i utrwał serializacji AgentSession w magazynie zaufanych aplikacji, gdy klienci muszą wznowić tę samą konwersację logiczną po ponownym uruchomieniu procesu.

Note

Integracja dostawcy kontekstu Redis nie jest obecnie udokumentowana dla języka Go platformy Agent Framework. Aktualny status znajdziesz w repozytorium Agent Framework dla Go.

Zagadnienia dotyczące środowiska produkcyjnego

  • Generowanie zakresów dzierżawy, wyszukiwania, pamięci i sesji z uwierzytelnionej tożsamości aplikacji, a nie danych wyjściowych modelu.
  • Użyj uwierzytelniania TLS, usługi Redis i izolacji sieci.
  • Użyj oddzielnych prefiksów kluczy lub wdrożeń, w których wymaga jej izolacja dzierżawy.
  • Skonfiguruj trwałość, kopie zapasowe, przechowywanie i eksmisję pod kątem wymaganej trwałości.
  • Traktuj pobraną pamięć jako niezaufane dane wejściowe i ograniczaj pośrednie wstrzyknięcie monitu.
  • Zredaguj zawartość wrażliwą przed utrwalaniem komunikatów lub indeksowaniem zawartości z możliwością wyszukiwania.

Następne kroki

Używanie programu RAG z TextSearchProvider

Mem0

Dowiedz się, jak działają dostawcy kontekstu

Głębiej:

  • Last updated on