Zprostředkovatelé kontextu

Zprostředkovatelé kontextu se spouští kolem každého vyvolání, aby před spuštěním a zpracování dat po spuštění přidali kontext.

Předdefinovaný vzor

Běžným postupem je konfigurovat poskytovatele prostřednictvím context_providers=[...] při vytváření agenta.

ChatHistoryProvider a AIContextProvider představují integrované body rozšíření pro krátkodobou historii a dlouhodobé rozšiřování kontextu.

V Pythonu InMemoryHistoryProvider je integrovaný zprostředkovatel historie používaný pro místní konverzační paměť.

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 může automaticky přidávat InMemoryHistoryProvider("memory") v konkrétních případech, ale přidat ho explicitně, pokud chcete deterministické chování místní paměti.

Vlastní zprostředkovatel kontextu

Vlastní zprostředkovatele kontextu použijte v případě, že po spuštění potřebujete vložit dynamické instrukce nebo zprávy nebo extrahovat stav.

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(".")

Vlastní zprostředkovatel historie

Zprostředkovatelé historie jsou zprostředkovatelé kontextu specializovaní na načítání a ukládání zpráv.

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

Důležité

V Pythonu můžete nakonfigurovat více poskytovatelů historie, ale měli byste použít load_messages=True . Používejte další zprostředkovatele pro diagnostiku a hodnocení spolu s load_messages=False a store_context_messages=True, tak aby zachytili kontext od jiných poskytovatelů společně se vstupem a výstupem.

Příklad vzoru:

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

Další kroky

Úložiště