cbrkit 0.27.2__tar.gz → 0.28.0__tar.gz

{cbrkit-0.27.2 → cbrkit-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cbrkit
-Version: 0.27.2
+Version: 0.28.0
 Summary: Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI
 Keywords: cbr,case-based reasoning,api,similarity,nlp,retrieval,cli,tool,library
 Author: Mirko Lenz
@@ -39,6 +39,7 @@ Requires-Dist: fastapi>=0.100,<1 ; extra == 'api'
 Requires-Dist: pydantic-settings>=2,<3 ; extra == 'api'
 Requires-Dist: python-multipart>=0.0.15,<1 ; extra == 'api'
 Requires-Dist: uvicorn[standard]>=0.30,<1 ; extra == 'api'
+Requires-Dist: fastmcp>=2,<3 ; extra == 'api'
 Requires-Dist: chonkie>=1,<2 ; extra == 'chunking'
 Requires-Dist: typer>=0.9,<1 ; extra == 'cli'
 Requires-Dist: ranx>=0.3,<1 ; extra == 'eval'
@@ -53,6 +54,8 @@ Requires-Dist: tiktoken>=0.8,<1 ; extra == 'llm'
 Requires-Dist: anthropic>=0.40,<1 ; extra == 'llm'
 Requires-Dist: google-genai>=1,<2 ; extra == 'llm'
 Requires-Dist: instructor>=1,<2 ; extra == 'llm'
+Requires-Dist: openai-agents>=0.2,<1 ; extra == 'llm'
+Requires-Dist: pydantic-ai-slim>=0.4,<1 ; extra == 'llm'
 Requires-Dist: bm25s[core,stem]>=0.2,<1 ; extra == 'nlp'
 Requires-Dist: levenshtein>=0.23,<0.26 ; platform_machine == 'x86_64' and sys_platform == 'darwin' and extra == 'nlp'
 Requires-Dist: levenshtein>=0.26,<1 ; (platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'nlp') or (sys_platform == 'linux' and extra == 'nlp')

{cbrkit-0.27.2 → cbrkit-0.28.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cbrkit"
-version = "0.27.2"
+version = "0.28.0"
 description = "Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI"
 authors = [{ name = "Mirko Lenz", email = "mirko@mirkolenz.com" }]
 readme = "README.md"
@@ -57,6 +57,7 @@ api = [
     "pydantic-settings>=2,<3",
     "python-multipart>=0.0.15,<1",
     "uvicorn[standard]>=0.30,<1",
+    "fastmcp>=2,<3",
 ]
 chunking = ["chonkie>=1,<2"]
 cli = ["typer>=0.9,<1"]
@@ -72,6 +73,8 @@ llm = [
     "anthropic>=0.40,<1",
     "google-genai>=1,<2",
     "instructor>=1,<2",
+    "openai-agents>=0.2,<1",
+    "pydantic-ai-slim>=0.4,<1",
 ]
 nlp = [
     "bm25s[core,stem]>=0.2,<1",

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/__init__.py

@@ -22,6 +22,7 @@ from . import (
     reuse,
     sim,
     synthesis,
+    system,
     typing,
 )
 
@@ -39,6 +40,7 @@ __all__ = [
     "synthesis",
     "typing",
     "constants",
+    "system",
 ]
 
 logging.getLogger(__name__).addHandler(logging.NullHandler())

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/api.py

@@ -56,7 +56,7 @@ def parse_dataset(obj: CasebaseSpec) -> Mapping[str, Any]:
         loader = cbrkit.loaders.structured_loaders[f".{obj.content_type}"]
         data = loader(obj.file)
     elif isinstance(obj, Path):
-        data = cbrkit.loaders.path(obj)
+        data = cbrkit.loaders.file(obj)
 
     if not all(isinstance(key, str) for key in data.keys()):
         return {str(key): value for key, value in data.items()}

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/cli.py

@@ -154,6 +154,8 @@ def serve(
 ) -> None:
     import uvicorn
 
+    from cbrkit.api import app
+
     sys.path.extend(str(x) for x in search_path)
 
     os.environ["CBRKIT_RETRIEVER"] = ",".join(retriever)
@@ -161,7 +163,29 @@ def serve(
     os.environ["CBRKIT_SYNTHESIZER"] = ",".join(synthesizer)
 
     uvicorn.run(
-        "cbrkit.api:app",
+        app,
+        host=host,
+        port=port,
+        reload=reload,
+        root_path=root_path,
+    )
+
+
+@app.command()
+def uvicorn(
+    app: str,
+    search_path: Annotated[list[Path], typer.Option(default_factory=list)],
+    host: str = "0.0.0.0",
+    port: int = 8080,
+    reload: bool = False,
+    root_path: str = "",
+) -> None:
+    import uvicorn
+
+    sys.path.extend(str(x) for x in search_path)
+
+    uvicorn.run(
+        app,
         host=host,
         port=port,
         reload=reload,

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/cycle.py

@@ -10,6 +10,7 @@ from .typing import Float, MaybeFactories, RetrieverFunc, ReuserFunc
 __all__ = [
     "apply_queries",
     "apply_batches",
+    "apply_query",
     "Result",
 ]
 
@@ -43,3 +44,17 @@ def apply_queries[Q, C, V, S: Float](
     return Result(
         retrieval=retrieval_result, reuse=reuse_result, duration=end_time - start_time
     )
+
+
+def apply_query[K, V, S: Float](
+    casebase: Mapping[K, V],
+    query: V,
+    retrievers: MaybeFactories[RetrieverFunc[K, V, S]],
+    reusers: MaybeFactories[ReuserFunc[K, V, S]],
+) -> Result[str, K, V, S]:
+    return apply_queries(
+        casebase,
+        {"default": query},
+        retrievers,
+        reusers,
+    )

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/helpers.py

@@ -115,19 +115,24 @@ class EventLoop:
 
     def close(self) -> None:
         if self._instance is not None:
-            tasks = asyncio.all_tasks(self._instance)
-            for task in tasks:
-                task.cancel()
-
             try:
-                self._instance.run_until_complete(
-                    asyncio.gather(*tasks, return_exceptions=True)
-                )
-            except asyncio.CancelledError:
+                tasks = asyncio.all_tasks(self._instance)
+                for task in tasks:
+                    task.cancel()
+
+                if tasks:
+                    self._instance.run_until_complete(
+                        asyncio.gather(*tasks, return_exceptions=True)
+                    )
+            except (RuntimeError, asyncio.CancelledError):
+                # Event loop may already be closed or unavailable
                 pass
-
             finally:
-                self._instance.close()
+                try:
+                    self._instance.close()
+                except RuntimeError:
+                    # Event loop may already be closed
+                    pass
                 self._instance = None
 
 

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/retrieval/rerank.py

@@ -250,6 +250,7 @@ with optional_dependencies():
 
         language: str
         stopwords: list[str] | None = None
+        auto_index: bool = False
         _indexed_retriever: bm25s.BM25 | None = field(
             default=None, init=False, repr=False
         )
@@ -265,7 +266,7 @@ with optional_dependencies():
         def _stemmer(self) -> Callable[..., Any]:
             return Stemmer.Stemmer(self.language)
 
-        def index(self, casebase: Casebase[K, str]) -> None:
+        def _build_retriever(self, casebase: Casebase[K, str]) -> bm25s.BM25:
             cases_tokens = bm25s.tokenize(
                 list(casebase.values()),
                 stemmer=self._stemmer,
@@ -273,6 +274,11 @@ with optional_dependencies():
             )
             retriever = bm25s.BM25()
             retriever.index(cases_tokens)
+
+            return retriever
+
+        def index(self, casebase: Casebase[K, str]) -> None:
+            retriever = self._build_retriever(casebase)
             self._indexed_retriever = retriever
             self._indexed_casebase = dict(casebase)
 
@@ -306,14 +312,11 @@ with optional_dependencies():
             if self._indexed_retriever and self._indexed_casebase == casebase:
                 retriever = self._indexed_retriever
             else:
-                cases_tokens = bm25s.tokenize(
-                    list(casebase.values()),
-                    stemmer=self._stemmer,
-                    stopwords=self._stopwords,
-                )
-                retriever = bm25s.BM25()
-                retriever.index(cases_tokens)
-                # TODO: maybe there should be an option to auto-persist on-demand indexing
+                retriever = self._build_retriever(casebase)
+
+                if self.auto_index:
+                    self._indexed_retriever = retriever
+                    self._indexed_casebase = dict(casebase)
 
             queries_tokens = bm25s.tokenize(
                 cast(list[str], queries),

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/sim/embed.py

@@ -1,7 +1,8 @@
 import asyncio
 import itertools
+import sqlite3
 from collections.abc import Iterator, MutableMapping, Sequence
-from contextlib import AbstractContextManager
+from contextlib import AbstractContextManager, contextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Literal, cast, override
@@ -170,71 +171,72 @@ class build[V, S: Float](BatchSimFunc[V, S]):
 class cache(BatchConversionFunc[str, NumpyArray]):
     func: BatchConversionFunc[str, NumpyArray] | None
     path: Path | None
-    autodump: bool
-    autoload: bool
+    table: str | None
     store: MutableMapping[str, NumpyArray] = field(repr=False)
-    mtime: float = field(repr=False)
 
     def __init__(
         self,
         func: AnyConversionFunc[str, NumpyArray] | None,
         path: FilePath | None = None,
-        autodump: bool = False,
-        autoload: bool = False,
+        table: str | None = None,
     ):
         self.func = batchify_conversion(func) if func is not None else None
         self.path = Path(path) if isinstance(path, str) else path
-        self.autodump = autodump
-        self.autoload = autoload
-        self.mtime = 0
+        self.table = table
+        self.store = {}
 
-        if self.path and self.path.exists():
-            self.load()
-        else:
-            self.store = {}
+        if self.path is not None:
+            if self.table is None:
+                raise ValueError("Table name must be specified for disk cache")
 
-    def dump(self) -> None:
-        if not self.path:
-            raise ValueError("Path not provided")
+            self.path.parent.mkdir(parents=True, exist_ok=True)
 
-        if not self.store:
-            logger.warning("Cache is empty, skipping dump")
-            return
-
-        if self.path.exists() and self.mtime < self.path.stat().st_mtime:
-            logger.warning("Cache file has been modified, skipping dump")
-            return
-
-        np.savez_compressed(self.path, **self.store)
-        self.mtime = self.path.stat().st_mtime
+            with self.connect() as connection:
+                connection.execute(f"""
+                    CREATE TABLE IF NOT EXISTS "{self.table}" (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        text TEXT NOT NULL UNIQUE,
+                        vector BLOB NOT NULL
+                    )
+                """)
 
-    def load(self) -> None:
-        if not self.path:
-            raise ValueError("Path not provided")
+                cursor = connection.execute(f'SELECT text, vector FROM "{self.table}"')
 
-        if not self.path.exists():
-            raise FileNotFoundError(f"Cache file '{self.path}' does not exist")
+                for text, vector_blob in cursor:
+                    self.store[text] = np.frombuffer(vector_blob, dtype=np.float64)
 
-        mtime = self.path.stat().st_mtime
+    @contextmanager
+    def connect(self) -> Iterator[sqlite3.Connection]:
+        if self.path is None:
+            raise ValueError("Path must be set to use the cache")
 
-        if self.mtime < mtime:
-            self.mtime = mtime
+        connection = sqlite3.connect(self.path)
 
-            with np.load(self.path) as data:
-                self.store = dict(data)
+        try:
+            yield connection
+        finally:
+            connection.close()
 
+    @override
     def __call__(self, texts: Sequence[str]) -> Sequence[NumpyArray]:
-        new_texts = [text for text in texts if text not in self.store]
+        # remove store entries and duplicates
+        new_texts = list({text for text in texts if text not in self.store})
 
         if new_texts:
-            if self.autoload:
-                self.load()
-
             if self.func:
-                self.store.update(zip(new_texts, self.func(new_texts), strict=True))
-
-                if self.autodump:
-                    self.dump()
+                new_vectors = self.func(new_texts)
+
+                for text, vector in zip(new_texts, new_vectors, strict=True):
+                    self.store[text] = vector
+
+                if self.path is not None:
+                    with self.connect() as connection:
+                        for text, vector in zip(new_texts, new_vectors, strict=True):
+                            vector_blob = vector.astype(np.float64).tobytes()
+                            connection.execute(
+                                f'INSERT OR IGNORE INTO "{self.table}" (text, vector) VALUES (?, ?)',
+                                (text, vector_blob),
+                            )
 
         return [self.store[text] for text in texts]
 

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/synthesis/providers/__init__.py

@@ -1,5 +1,6 @@
 from ...helpers import optional_dependencies
 from .model import (
+    AsyncProvider,
     BaseProvider,
     ChatMessage,
     ChatPrompt,
@@ -20,6 +21,10 @@ with optional_dependencies():
     from .anthropic import anthropic
 with optional_dependencies():
     from .instructor import instructor
+with optional_dependencies():
+    from .pydantic_ai import pydantic_ai
+with optional_dependencies():
+    from .openai_agents import openai_agents
 
 __all__ = [
     "openai",
@@ -27,6 +32,7 @@ __all__ = [
     "cohere",
     "conversation",
     "pipe",
+    "AsyncProvider",
     "BaseProvider",
     "ChatProvider",
     "ChatMessage",
@@ -36,4 +42,6 @@ __all__ = [
     "Usage",
     "anthropic",
     "instructor",
+    "pydantic_ai",
+    "openai_agents",
 ]

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/synthesis/providers/google.py

@@ -14,7 +14,6 @@ with optional_dependencies():
 
     @dataclass(slots=True)
     class google[R: BaseModel | str](BaseProvider[GooglePrompt, R]):
-        system_message: str | None = None
         client: Client = field(default_factory=Client, repr=False)
         config: GenerateContentConfig = field(init=False)
         base_config: InitVar[GenerateContentConfig | None] = None

{cbrkit-0.27.2 → cbrkit-0.28.0}/src/cbrkit/synthesis/providers/model.py

@@ -2,7 +2,7 @@ import asyncio
 from abc import ABC, abstractmethod
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
-from typing import Any, Literal
+from typing import Any, Literal, override
 
 from pydantic import Field
 
@@ -44,19 +44,12 @@ class Response[T](StructuredValue[T]):
 
 
 @dataclass(slots=True, kw_only=True)
-class BaseProvider[P, R](BatchConversionFunc[P, Response[R]], ABC):
-    model: str
-    response_type: type[R]
-    delay: float = 0
-    retries: int = 0
-    default_response: R | None = None
-    extra_kwargs: Mapping[str, Any] = field(default_factory=dict)
-
-    def __call__(self, batches: Sequence[P]) -> Sequence[Response[R]]:
+class AsyncProvider[P, R](BatchConversionFunc[P, R], ABC):
+    def __call__(self, batches: Sequence[P]) -> Sequence[R]:
         return event_loop.get().run_until_complete(self.__call_batches__(batches))
 
-    async def __call_batches__(self, batches: Sequence[P]) -> Sequence[Response[R]]:
-        logger.info(f"Processing {len(batches)} batches with {self.model}")
+    async def __call_batches__(self, batches: Sequence[P]) -> Sequence[R]:
+        logger.info(f"Processing {len(batches)} batches")
 
         return await asyncio.gather(
             *(
@@ -65,6 +58,26 @@ class BaseProvider[P, R](BatchConversionFunc[P, Response[R]], ABC):
             )
         )
 
+    async def __call_batch_wrapper__(self, prompt: P, idx: int) -> R:
+        result = await self.__call_batch__(prompt)
+        logger.debug(f"Result of batch {idx + 1}: {result}")
+        return result
+
+    @abstractmethod
+    async def __call_batch__(self, prompt: P) -> R: ...
+
+
+@dataclass(slots=True, kw_only=True)
+class BaseProvider[P, R](AsyncProvider[P, Response[R]], ABC):
+    model: str
+    response_type: type[R]
+    system_message: str | None = None
+    delay: float = 0
+    retries: int = 0
+    default_response: R | None = None
+    extra_kwargs: Mapping[str, Any] = field(default_factory=dict)
+
+    @override
     async def __call_batch_wrapper__(
         self, prompt: P, idx: int, retry: int = 0
     ) -> Response[R]:
@@ -72,9 +85,7 @@ class BaseProvider[P, R](BatchConversionFunc[P, Response[R]], ABC):
             await asyncio.sleep(idx * self.delay)
 
         try:
-            result = await self.__call_batch__(prompt)
-            logger.debug(f"Result of batch {idx + 1}: {result}")
-            return result
+            return await super(BaseProvider, self).__call_batch_wrapper__(prompt, idx)
 
         except Exception as e:
             if retry < self.retries:
@@ -87,11 +98,7 @@ class BaseProvider[P, R](BatchConversionFunc[P, Response[R]], ABC):
 
             raise e
 
-    @abstractmethod
-    async def __call_batch__(self, prompt: P) -> Response[R]: ...
-
 
 @dataclass(slots=True, kw_only=True)
 class ChatProvider[P, R](BaseProvider[P, R], ABC):
-    system_message: str | None = None
     messages: Sequence[ChatMessage] = field(default_factory=tuple)

cbrkit-0.28.0/src/cbrkit/synthesis/providers/openai_agents.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from functools import partial
+from typing import cast, override
+from uuid import uuid1
+
+from cbrkit import helpers
+from cbrkit.typing import MaybeSequence
+
+from ...helpers import get_logger, optional_dependencies
+from .model import AsyncProvider
+
+logger = get_logger(__name__)
+
+with optional_dependencies():
+    from agents import (
+        Agent,
+        RunConfig,
+        RunHooks,
+        Runner,
+        RunResult,
+        SQLiteSession,
+        TResponseInputItem,
+    )
+    from agents.run import DEFAULT_MAX_TURNS
+
+    type OpenaiAgentsPrompt = str | list[TResponseInputItem]
+
+    # the output is any in the base class, so we override it here
+    class TypedRunResult[R](RunResult):
+        final_output: R
+
+    @dataclass(slots=True)
+    class openai_agents[T, R](AsyncProvider[OpenaiAgentsPrompt, TypedRunResult[R]]):
+        agents: MaybeSequence[Agent[T]]
+        context: T | None = None
+        max_turns: int = DEFAULT_MAX_TURNS
+        hooks: RunHooks[T] | None = None
+        run_config: RunConfig | None = None
+
+        @override
+        async def __call_batch__(self, prompt: OpenaiAgentsPrompt) -> TypedRunResult[R]:
+            agents = helpers.produce_sequence(self.agents)
+
+            if not agents:
+                raise ValueError("No agents given.")
+
+            head_agent, *tail_agents = agents
+
+            session = SQLiteSession(uuid1().hex) if len(agents) > 1 else None
+
+            run = partial(
+                Runner.run,
+                context=self.context,
+                max_turns=self.max_turns,
+                hooks=self.hooks,
+                run_config=self.run_config,
+                session=session,
+            )
+
+            response: RunResult = await run(head_agent, prompt)
+
+            for agent in tail_agents:
+                response = await run(agent, [])
+
+            return cast(TypedRunResult[R], response)

cbrkit-0.28.0/src/cbrkit/synthesis/providers/pydantic_ai.py

@@ -0,0 +1,43 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import override
+
+from cbrkit import helpers
+from cbrkit.typing import MaybeSequence
+
+from ...helpers import get_logger, optional_dependencies
+from .model import AsyncProvider
+
+logger = get_logger(__name__)
+
+with optional_dependencies():
+    from pydantic_ai.agent import Agent, AgentRunResult
+    from pydantic_ai.messages import UserContent
+
+    type PydanticAiPrompt = str | Sequence[UserContent]
+
+    @dataclass(slots=True)
+    class pydantic_ai[T, R](AsyncProvider[PydanticAiPrompt, AgentRunResult[R]]):
+        agents: MaybeSequence[Agent[T, R]]
+        deps: T
+
+        @override
+        async def __call_batch__(self, prompt: PydanticAiPrompt) -> AgentRunResult[R]:
+            agents = helpers.produce_sequence(self.agents)
+
+            if not agents:
+                raise ValueError("No agents given.")
+
+            head_agent, *tail_agents = agents
+
+            response: AgentRunResult[R] = await head_agent.run(prompt, deps=self.deps)
+
+            for agent in tail_agents:
+                response = await agent.run(
+                    # inject the system prompt because the default is not used if message history is provided
+                    agent._system_prompts,
+                    deps=self.deps,
+                    message_history=response.all_messages() if response else None,
+                )
+
+            return response

cbrkit-0.28.0/src/cbrkit/system.py

@@ -0,0 +1,157 @@
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+
+from pydantic import BaseModel
+from typing_extensions import Any
+
+import cbrkit
+from cbrkit.helpers import produce_sequence
+from cbrkit.typing import Float, MaybeSequence
+
+__all__ = [
+    "System",
+    "to_fastapi",
+    "to_fastmcp",
+    "to_pydantic_ai",
+]
+
+
+@dataclass(slots=True, frozen=True)
+class System[K: str | int, V: BaseModel, S: Float]:
+    casebase: cbrkit.typing.Casebase[K, V]
+    model: type[V]
+    retriever_pipelines: Mapping[
+        str, MaybeSequence[cbrkit.typing.RetrieverFunc[K, V, S]]
+    ] = field(default_factory=dict)
+    reuser_pipelines: Mapping[str, MaybeSequence[cbrkit.typing.ReuserFunc[K, V, S]]] = (
+        field(default_factory=dict)
+    )
+
+    def get_retriever_pipeline(
+        self, name: str, limit: int | None
+    ) -> Sequence[cbrkit.typing.RetrieverFunc[K, V, S]]:
+        retrievers = produce_sequence(self.retriever_pipelines[name])
+
+        if limit is not None:
+            *head_retrievers, tail_retriever = retrievers
+            retrievers = head_retrievers + [
+                cbrkit.retrieval.dropout(tail_retriever, limit=limit)
+            ]
+
+        return retrievers
+
+    def retrieve(
+        self,
+        query: V,
+        retriever_pipeline: str,
+        limit: int | None = None,
+    ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+        return cbrkit.retrieval.apply_query(
+            self.casebase,
+            query,
+            self.get_retriever_pipeline(retriever_pipeline, limit),
+        ).default_query
+
+    def reuse(
+        self,
+        query: V,
+        reuser_pipeline: str,
+    ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+        return cbrkit.reuse.apply_query(
+            self.casebase,
+            query,
+            self.reuser_pipelines[reuser_pipeline],
+        ).default_query
+
+    def cycle(
+        self,
+        query: V,
+        retriever_pipeline: str,
+        reuser_pipeline: str,
+        limit: int | None = None,
+    ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+        return cbrkit.cycle.apply_query(
+            self.casebase,
+            query,
+            self.get_retriever_pipeline(retriever_pipeline, limit),
+            self.reuser_pipelines[reuser_pipeline],
+        ).final_step.default_query
+
+    @property
+    def tools(self) -> list[Callable[..., Any]]:
+        res: list[Callable[..., Any]] = []
+
+        if self.retriever_pipelines:
+            res.append(self.retrieve)
+
+        if self.reuser_pipelines:
+            res.append(self.reuse)
+
+        if self.retriever_pipelines and self.reuser_pipelines:
+            res.append(self.cycle)
+
+        return res
+
+    def get_case(self, name: K) -> V:
+        return self.casebase[name]
+
+    def get_retriever_names(self) -> list[str]:
+        return list(self.retriever_pipelines.keys())
+
+    def get_reuser_names(self) -> list[str]:
+        return list(self.reuser_pipelines.keys())
+
+    @property
+    def resources(self) -> dict[str, Callable[..., Any]]:
+        return {
+            "casebase/{name}": self.get_case,
+            "pipelines/retrieve": self.get_retriever_names,
+            "pipelines/reuse": self.get_reuser_names,
+        }
+
+    @property
+    def prompts(self) -> list[Callable[..., Any]]:
+        return []
+
+
+with cbrkit.helpers.optional_dependencies():
+    from fastapi import FastAPI
+
+    def to_fastapi(system: System) -> FastAPI:
+        app = FastAPI()
+
+        for value in system.tools:
+            app.post(f"/tool/{value.__name__}")(value)
+
+        for key, value in system.resources.items():
+            app.get(f"/resource/{key}")(value)
+
+        for value in system.prompts:
+            app.post(f"/prompt/{value.__name__}")(value)
+
+        return app
+
+
+with cbrkit.helpers.optional_dependencies():
+    from fastmcp import FastMCP
+
+    def to_fastmcp(system: System) -> FastMCP[Any]:
+        app = FastMCP()
+
+        for value in system.tools:
+            app.tool(value)
+
+        for key, value in system.resources.items():
+            app.resource(f"cbrkit://{key}")(value)
+
+        for value in system.prompts:
+            app.prompt(value)
+
+        return app
+
+
+with cbrkit.helpers.optional_dependencies():
+    from pydantic_ai.toolsets import FunctionToolset
+
+    def to_pydantic_ai(system: System) -> FunctionToolset[Any]:
+        return FunctionToolset(system.tools)