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 dla Agent Framework udostępnia dostawców pamięci i historii rozmów z możliwością przeszukiwania dla języka Python.

Wzór API SDK Behavior
RAG TextSearchProvider z adapterem 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 rozmowy i pobiera odpowiedni kontekst za pomocą wyszukiwania pełnotekstowego lub hybrydowego wyszukiwania wektorowego.
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 TextSearchProvider niezależnego od dostawcy dla platformy .NET. Zaimplementuj adapter wyszukiwania przy użyciu klienta Redis lub konektora magazynu wektorowego wybranego przez aplikację, zamapuj wyniki Redis na TextSearchProvider.TextSearchResult, a następnie podłącz dostawcę za pomocą AIContextProviders.

Takie podejście obsługuje RAG oparty na Redis bez konieczności używania pakietu dostawcy kontekstu dla Agent Framework specyficznego dla Redis.

Instalowanie pakietu 

pip install agent-framework-redis --pre

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

Użyj tego wzorca, gdy agent powinien przywołać wybrane istotne informacje, zamiast odtwarzać każdy poprzedni komunikat.

Wymagania wstępne

  • Wdrożenie Redis z obsługą RediSearch, na przykład Redis Stack lub kompatybilna 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

Pobieranie pamięci z możliwością wyszukiwania działa między sesjami. Każdy podany application_id, agent_id i user_id działa jak filtr AND, podczas gdy pominięte wymiary nie są filtrowane. Musisz podać co najmniej jeden identyfikator. Podaj każdy stabilny, zaufany identyfikator reprezentujący docelową granicę izolacji.

Dodaj wektoryzator Redis oraz ustawienia pola wektorowego, jeśli chcesz używać wyszukiwania hybrydowego.

# 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łącz pamięć 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.
  • TLS i uwierzytelnieni użytkownicy Redis dla wdrożeń produkcyjnych.

Dołącz od RedisHistoryProvider do 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,
        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}")

Klucze zakresowe są domyślne. Ustaw stabilną, niepustą wartość application_id i użyj tenant_id oraz agent_id, gdy aplikacja ma takie granice izolacji. Dostawca określa również zakres każdego klucza na podstawie jego source_id oraz niepustego identyfikatora sesji.

Użyj stabilnego identyfikatora sesji i zachowaj zserializowane AgentSession w zaufanym magazynie danych aplikacji, gdy klienci muszą wznowić tę samą logiczną konwersację po ponownym uruchomieniu procesu.

Wcześniejsze wersje przechowywały historię w {key_prefix}:{session_id or "default"}. Istniejące wdrożenia mogą tymczasowo ustawić wartość key_format="legacy" na czas migracji. Tryb starszej wersji jest przestarzały, nie akceptuje identyfikatorów o określonym zakresie, a tryb o określonym zakresie nigdy nie odczytuje, zapisuje ponownie lub usuwa starsze klucze. Skopiuj tylko zweryfikowane rekordy do odpowiednich kluczy zakresowych, zweryfikuj zmigrowaną historię, a następnie usuń starsze klucze zgodnie z polityką retencji.

Uwaga / Notatka

Integracja z dostawcą kontekstu Redis nie jest obecnie udokumentowana w Agent Framework Go. Aktualny status znajdziesz w repozytorium Agent Framework dla Go.

Zagadnienia dotyczące środowiska produkcyjnego

  • Wyprowadzaj zakresy dzierżawcy, wyszukiwania, pamięci i sesji na podstawie uwierzytelnionej tożsamości aplikacji, a nie wyniku modelu.
  • Użyj uwierzytelniania TLS, usługi Redis i izolacji sieci.
  • Dla historii konwersacji w Pythonie ustaw zakresy tenantu, aplikacji, agenta, źródła dostawcy i sesji tam, gdzie te granice istnieją.
  • 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żyj RAG z TextSearchProvider

Mem0

Dowiedz się, jak działają dostawcy kontekstu

Głębiej:

  • Last updated on