Dostawcy kontekstu

Dostawcy kontekstu działają zarówno przed, jak i po każdym wywołaniu, aby dodać kontekst przed wykonaniem oraz przetworzyć dane po wykonaniu.

Wzorzec wbudowany

Regularnym wzorcem jest skonfigurowanie dostawców za pośrednictwem context_providers=[...] podczas tworzenia agenta.

ChatHistoryProvider i AIContextProvider są wbudowanymi punktami rozszerzenia dla historii krótkoterminowej i długoterminowego ubogacenia kontekstu.

W przypadku języka Python InMemoryHistoryProvider jest wbudowanym dostawcą historii używanym do lokalnej pamięci konwersacyjnej.

from agent_framework import InMemoryHistoryProvider
from agent_framework.openai import OpenAIChatClient

agent = OpenAIChatClient().as_agent(
    name="MemoryBot",
    instructions="You are a helpful assistant.",
    context_providers=[InMemoryHistoryProvider("memory", load_messages=True)],
)

session = agent.create_session()
await agent.run("Remember that I prefer vegetarian food.", session=session)

RawAgent może automatycznie dodawać InMemoryHistoryProvider("memory") w określonych przypadkach, ale dodać je jawnie, gdy chcesz deterministyczne zachowanie pamięci lokalnej.

Niestandardowy dostawca kontekstu

Użyj niestandardowych dostawców kontekstu, gdy musisz wstrzyknąć instrukcje dynamiczne/komunikaty lub wyodrębnić stan po uruchomieniu.

from typing import Any

from agent_framework import AgentSession, BaseContextProvider, SessionContext


class UserPreferenceProvider(BaseContextProvider):
    def __init__(self) -> None:
        super().__init__("user-preferences")

    async def before_run(
        self,
        *,
        agent: Any,
        session: AgentSession,
        context: SessionContext,
        state: dict[str, Any],
    ) -> None:
        if favorite := state.get("favorite_food"):
            context.extend_instructions(self.source_id, f"User's favorite food is {favorite}.")

    async def after_run(
        self,
        *,
        agent: Any,
        session: AgentSession,
        context: SessionContext,
        state: dict[str, Any],
    ) -> None:
        for message in context.input_messages:
            text = (message.text or "") if hasattr(message, "text") else ""
            if isinstance(text, str) and "favorite food is" in text.lower():
                state["favorite_food"] = text.split("favorite food is", 1)[1].strip().rstrip(".")

Niestandardowy dostawca historii

Dostawcy historii to dostawcy kontekstu wyspecjalizowani do ładowania/przechowywania komunikatów.

from collections.abc import Sequence
from typing import Any

from agent_framework import BaseHistoryProvider, Message


class DatabaseHistoryProvider(BaseHistoryProvider):
    def __init__(self, db: Any) -> None:
        super().__init__("db-history", load_messages=True)
        self._db = db

    async def get_messages(
        self,
        session_id: str | None,
        *,
        state: dict[str, Any] | None = None,
        **kwargs: Any,
    ) -> list[Message]:
        key = (state or {}).get(self.source_id, {}).get("history_key", session_id or "default")
        rows = await self._db.load_messages(key)
        return [Message.from_dict(row) for row in rows]

    async def save_messages(
        self,
        session_id: str | None,
        messages: Sequence[Message],
        *,
        state: dict[str, Any] | None = None,
        **kwargs: Any,
    ) -> None:
        if not messages:
            return
        if state is not None:
            key = state.setdefault(self.source_id, {}).setdefault("history_key", session_id or "default")
        else:
            key = session_id or "default"
        await self._db.save_messages(key, [m.to_dict() for m in messages])

Ważne

W języku Python można skonfigurować wielu dostawców historii, ale należy użyć tylko jednego z nich load_messages=True. Użyj dodatkowych dostawców do diagnostyki/oceny z load_messages=False i store_context_messages=True, aby przechwytywali kontekst od innych dostawców wraz z danymi wejściowymi/wyjściowymi.

Przykładowy wzorzec:

primary = DatabaseHistoryProvider(db)
audit = InMemoryHistoryProvider("audit", load_messages=False, store_context_messages=True)
agent = OpenAIChatClient().as_agent(context_providers=[primary, audit])

Dalsze kroki

Przechowywanie