ai-microcore 4.0.0.dev11__tar.gz → 4.0.0.dev12__tar.gz

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/PKG-INFO

@@ -1,14 +1,16 @@
 Metadata-Version: 2.4
 Name: ai-microcore
-Version: 4.0.0.dev11
+Version: 4.0.0.dev12
 Summary: # Minimalistic Foundation for AI Applications
-Keywords: llm,large language models,ai,similarity search,ai search,gpt,openai
+Keywords: llm,large language models,ai,similarity search,ai search,gpt,openai,framework,adapter
 Author-email: Vitalii Stepanenko <mail@vitalii.in>
 Maintainer-email: Vitalii Stepanenko <mail@vitalii.in>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
@@ -21,6 +23,7 @@ Requires-Dist: colorama~=0.4.6
 Requires-Dist: PyYAML~=6.0
 Requires-Dist: chardet~=5.2.0
 Requires-Dist: tiktoken>=0.7.0,<1.0
+Requires-Dist: mcp~=1.9.1
 Project-URL: Source Code, https://github.com/Nayjest/ai-microcore
 
 <p align="right">
@@ -35,7 +38,7 @@ Project-URL: Source Code, https://github.com/Nayjest/ai-microcore
 # AI MicroCore: A Minimalistic Foundation for AI Applications
 
 **MicroCore** is a collection of python adapters for Large Language Models
-and Semantic Search APIs allowing to 
+and Vector Databases / Semantic Search APIs allowing to 
 communicate with these services in a convenient way, make them easily switchable 
 and separate business logic from the implementation details.
 
@@ -45,6 +48,10 @@ without need to change your application code.
 
 You even can switch between text completion and chat completion models only using configuration.
 
+Thanks to LLM-agnostic MCP integration,
+**MicroCore** connects MCP tools to any language models easily,
+whether through API providers that do not support MCP, or through inference using pytorch or arbitrary python functions.
+
 The basic example of usage is as follows:
 
 ```python
@@ -288,7 +295,6 @@ import microcore.ai_modules
 
 *   Automatically registers template folders of AI modules in Jinja2 environment
 
-
 ## 🛠️ Contributing
 
 Please see [CONTRIBUTING](https://github.com/Nayjest/ai-microcore/blob/main/CONTRIBUTING.md) for details.

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/README.md

@@ -10,7 +10,7 @@
 # AI MicroCore: A Minimalistic Foundation for AI Applications
 
 **MicroCore** is a collection of python adapters for Large Language Models
-and Semantic Search APIs allowing to 
+and Vector Databases / Semantic Search APIs allowing to 
 communicate with these services in a convenient way, make them easily switchable 
 and separate business logic from the implementation details.
 
@@ -20,6 +20,10 @@ without need to change your application code.
 
 You even can switch between text completion and chat completion models only using configuration.
 
+Thanks to LLM-agnostic MCP integration,
+**MicroCore** connects MCP tools to any language models easily,
+whether through API providers that do not support MCP, or through inference using pytorch or arbitrary python functions.
+
 The basic example of usage is as follows:
 
 ```python
@@ -263,7 +267,6 @@ import microcore.ai_modules
 
 *   Automatically registers template folders of AI modules in Jinja2 environment
 
-
 ## 🛠️ Contributing
 
 Please see [CONTRIBUTING](https://github.com/Nayjest/ai-microcore/blob/main/CONTRIBUTING.md) for details.

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/__init__.py

@@ -8,8 +8,9 @@ and separate business logic from implementation details.
 """
 
 import os
-import microcore.ui  # noqa
-import microcore.tokenizing  # noqa
+from . import mcp
+from . import ui
+from . import tokenizing
 from .embedding_db import SearchResult, AbstractEmbeddingDB, SearchResults
 from .file_storage import storage
 from ._env import configure, env, config
@@ -22,7 +23,6 @@ from .wrappers.llm_response_wrapper import LLMResponse
 from ._llm_functions import llm, allm, llm_parallel
 from .utils import parse, dedent
 from .metrics import Metrics
-from .interactive_setup import interactive_setup
 
 
 def tpl(file: os.PathLike[str] | str, **kwargs) -> str | PromptWrapper:
@@ -120,6 +120,23 @@ class _EmbeddingDBProxy(AbstractEmbeddingDB):
 texts = _EmbeddingDBProxy()
 """Embedding database, see `microcore.embedding_db.AbstractEmbeddingDB`"""
 
+
+def mcp_server(name: str) -> mcp.MCPServer:  # noqa, pylint-disable=E0602
+    """
+    Returns MCP server by name from the registry.
+
+    Args:
+        name (str): The name of the MCP server.
+
+    Returns:
+        MCPServer: The MCP server instance.
+
+    Raises:
+        ValueError: If the server with the given name is not found in the registry.
+    """
+    return mcp.server(name)  # noqa, pylint-disable=E0602
+
+
 __all__ = [
     "llm",
     "allm",
@@ -160,9 +177,11 @@ __all__ = [
     "Config",
     "types",
     "ui",
+    "mcp",
+    "mcp_server",
+    "tokenizing",
     "Metrics",
-    "interactive_setup"
     # "wrappers",
 ]
 
-__version__ = "4.0.0-dev11"
+__version__ = "4.0.0-dev12"

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/_env.py

@@ -15,6 +15,7 @@ from .llm.local_llm import make_llm_functions as make_local_llm_functions
 if TYPE_CHECKING:
     from .wrappers.llm_response_wrapper import LLMResponse  # noqa: F401
     from transformers import PreTrainedModel, PreTrainedTokenizer  # noqa: F401
+    from .mcp import MCPRegistry
 
 
 @dataclass
@@ -33,6 +34,7 @@ class Env:
     tokenizer: "PreTrainedTokenizer" = field(  # noqa
         default=None, init=False, repr=False
     )
+    _mcp_registry: "MCPRegistry" = field(init=False, default=None)
 
     def __post_init__(self):
         global _env
@@ -52,6 +54,13 @@ class Env:
         self.jinja_env = make_jinja2_env(self)
         self.tpl_function = make_tpl_function(self)
 
+    @property
+    def mcp_registry(self):
+        if self._mcp_registry is None:
+            from .mcp import MCPRegistry
+            self._mcp_registry = MCPRegistry(self.config.MCP_SERVERS)
+        return self._mcp_registry
+
     def init_llm(self):
         if self.config.LLM_API_TYPE == ApiType.NONE:
 

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/ai_func/__init__.py

@@ -8,8 +8,8 @@ import inspect
 from enum import Enum
 from typing import Dict, Any
 import docstring_parser
-from .. import tpl
 from ..utils import dedent
+from .._env import env
 
 
 class AiFuncSyntax(str, Enum):
@@ -95,4 +95,4 @@ def describe_ai_func(func: callable, syntax: AiFuncSyntax | str = None) -> str:
     syntax = syntax or AiFuncSyntax.DEFAULT
     tpl_file = f"ai-func.{syntax}.j2" if syntax in AiFuncSyntax else syntax
     metadata = func_metadata(func)
-    return tpl(tpl_file, **metadata)
+    return env().tpl_function(tpl_file, **metadata)

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/ai_func/ai-func.json.j2

@@ -1,6 +1,6 @@
 # {{ description or name.replace('_', ' ').capitalize() }}
 {
-  "call": "{{ name }}"{% if args %}{{ "," }}{% endif %}
+  "{{ config.AI_SYNTAX_FUNCTION_NAME_FIELD }}": "{{ name }}"{% if args %}{{ "," }}{% endif %}
 {%- for k,v in args.items() %}
   "{{ k }}":
     {%- if v.type %} <{{ v.type }}>{% endif -%}

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/configuration.py

@@ -404,6 +404,12 @@ class Config(LLMConfig):
       - LLMResponse objects will not contain the links to the prompt field
     """
 
+    AI_SYNTAX_FUNCTION_NAME_FIELD: str = from_env(default="call")
+
+    JINJA2_GLOBALS: dict = from_env(dtype=dict)
+
+    MCP_SERVERS: list = from_env(dtype=list)
+
     def __post_init__(self):
         super().__post_init__()
         if self.TEXT_TO_SPEECH_PATH is None:

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/interactive_setup.py

@@ -1,75 +1,77 @@
-from .configuration import EmbeddingDbType, ApiType
-from .ui import ask_choose, ask_non_empty, ask_yn, error, yellow
-from ._env import configure
-from ._llm_functions import llm
-from .utils import file_link
-
-
-def interactive_setup(
-    file_path: str,
-    defaults: dict = None,
-    extras: dict | list = None,
-):
-    """
-    Interactive setup for LLM API configuration.
-    Prompts user for configuration details such as API type, key, model name,
-    and base URL. Tests the LLM API with a sample query and saves the configuration
-    to a specified file if the user chooses to do so.
-    Args:
-        file_path (str): Path to the configuration file.
-        defaults (dict, optional): Default configuration values.
-            If provided, user will not be prompted for those values.
-            Additional values for storing in the file can be added to defaults.
-        extras (dict | list, optional): Additional configuration fields to prompt for.
-    """
-    raw_config = dict(defaults) if defaults else dict()
-    if "LLM_API_TYPE" not in raw_config:
-        raw_config["LLM_API_TYPE"] = ask_choose(
-            "Choose LLM API Type:",
-            list(i.value for i in ApiType if not ApiType.is_local(i)),
-        )
-    if "LLM_API_KEY" not in raw_config:
-        raw_config["LLM_API_KEY"] = ask_non_empty("API Key: ")
-    if "MODEL" not in raw_config:
-        raw_config["MODEL"] = ask_non_empty("Model Name: ")
-    if "LLM_API_BASE" not in raw_config:
-        raw_config["LLM_API_BASE"] = input("API Base URL (may be empty for some API types): ")
-    if extras:
-        if isinstance(extras, list):
-            extras = {
-                i: str(i)
-                    .replace('_', ' ')
-                    .capitalize()
-                    .replace('Llm', 'LLM')
-                    .replace('Api', 'API')
-                for i in extras
-            }
-        for field, title in extras.items():
-            if field not in raw_config:
-                raw_config[field] = ask_non_empty(f"{title}: ")
-    try:
-        configure(
-            **{
-                **dict(
-                    USE_DOT_ENV=False,
-                    EMBEDDING_DB_TYPE=EmbeddingDbType.NONE,
-                    USE_LOGGING=True,
-                ),
-                **raw_config
-            }
-        )
-        print("Testing LLM...")
-        q = "What is capital of France?\n(!) IMPORTANT: Answer only with one word"
-        assert "pari" in llm(q).lower()
-    except Exception as e:  # pylint: disable=W0718
-        error(f"Error testing LLM API: {e}")
-        if ask_yn("Restart configuring?"):
-            interactive_setup(file_path, defaults, extras)
-        return
-
-    config_body = ''.join(f"{k}={v}\n" for k, v in raw_config.items())
-    print(f"Configuration:\n{yellow(config_body)}")
-    if ask_yn("Save configuration to file?"):
-        print(f"Saved to {file_link(file_path)}")
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(config_body)
+from .configuration import EmbeddingDbType, ApiType
+from .ui import ask_choose, ask_non_empty, ask_yn, error, yellow
+from ._env import configure
+from ._llm_functions import llm
+from .utils import file_link
+
+
+def interactive_setup(
+    file_path: str,
+    defaults: dict = None,
+    extras: dict | list = None,
+):
+    """
+    Interactive setup for LLM API configuration.
+    Prompts user for configuration details such as API type, key, model name,
+    and base URL. Tests the LLM API with a sample query and saves the configuration
+    to a specified file if the user chooses to do so.
+    Args:
+        file_path (str): Path to the configuration file.
+        defaults (dict, optional): Default configuration values.
+            If provided, user will not be prompted for those values.
+            Additional values for storing in the file can be added to defaults.
+        extras (dict | list, optional): Additional configuration fields to prompt for.
+    """
+    raw_config = dict(defaults) if defaults else dict()
+    if "LLM_API_TYPE" not in raw_config:
+        raw_config["LLM_API_TYPE"] = ask_choose(
+            "Choose LLM API Type:",
+            list(i.value for i in ApiType if not ApiType.is_local(i)),
+        )
+    if "LLM_API_KEY" not in raw_config:
+        raw_config["LLM_API_KEY"] = ask_non_empty("API Key: ")
+    if "MODEL" not in raw_config:
+        raw_config["MODEL"] = ask_non_empty("Model Name: ")
+    if "LLM_API_BASE" not in raw_config:
+        raw_config["LLM_API_BASE"] = input("API Base URL (may be empty for some API types): ")
+    if extras:
+        if isinstance(extras, list):
+            extras = {
+                i: (
+                    str(i)
+                    .replace('_', ' ')
+                    .capitalize()
+                    .replace('Llm', 'LLM')
+                    .replace('Api', 'API')
+                )
+                for i in extras
+            }
+        for field, title in extras.items():
+            if field not in raw_config:
+                raw_config[field] = ask_non_empty(f"{title}: ")
+    try:
+        configure(
+            **{
+                **dict(
+                    USE_DOT_ENV=False,
+                    EMBEDDING_DB_TYPE=EmbeddingDbType.NONE,
+                    USE_LOGGING=True,
+                ),
+                **raw_config
+            }
+        )
+        print("Testing LLM...")
+        q = "What is capital of France?\n(!) IMPORTANT: Answer only with one word"
+        assert "pari" in llm(q).lower()
+    except Exception as e:  # pylint: disable=W0718
+        error(f"Error testing LLM API: {e}")
+        if ask_yn("Restart configuring?"):
+            interactive_setup(file_path, defaults, extras)
+        return
+
+    config_body = ''.join(f"{k}={v}\n" for k, v in raw_config.items())
+    print(f"Configuration:\n{yellow(config_body)}")
+    if ask_yn("Save configuration to file?"):
+        print(f"Saved to {file_link(file_path)}")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(config_body)

ai_microcore-4.0.0.dev12/microcore/mcp.py

@@ -0,0 +1,280 @@
+import asyncio
+import logging
+from typing import Optional
+from dataclasses import dataclass, field
+
+from mcp.client.streamable_http import streamablehttp_client
+from mcp import ClientSession, types
+
+from .utils import ExtendedString
+from .ai_func import AiFuncSyntax
+from . import ui
+from .types import BadAIAnswer, BadAIJsonAnswer
+from .wrappers.llm_response_wrapper import LLMResponse
+from ._env import env
+from .file_storage import storage
+
+
+class WrongMcpUsage(BadAIAnswer):
+    ...
+
+
+class ToolsCache:
+    FILE = "mcp/tools.json"
+
+    @staticmethod
+    def read(mcp_url: str) -> Optional["Tools"]:
+        logging.info(f"Checking MCP tools cache for {ui.green(mcp_url)}...")
+        tools = storage.read_json(ToolsCache.FILE, default={}).get(mcp_url, None)
+        if tools is not None:
+            return Tools.from_list([Tool(**raw) for raw in tools.values()])
+        return None
+
+    @staticmethod
+    def write(mcp_url: str, tools: "Tools"):
+        logging.info(f"Storing MCP tools cache for {ui.green(mcp_url)}...")
+        cached_tools = storage.read_json(ToolsCache.FILE, default={})
+        cached_tools[mcp_url] = tools
+        storage.write_json(ToolsCache.FILE, cached_tools)
+
+
+@dataclass
+class MCPConnection:
+    url: str = None
+    read_stream: any = None
+    write_stream: any = None
+    connection: any = None
+    context_manager: any = None
+    session: ClientSession = field(default=None, init=False)
+    del_event: asyncio.Event = field(default=None, init=False)
+    tools: Optional["Tools"] = field(default=None, init=False)
+
+    @staticmethod
+    async def init(
+        url: str,
+        fetch_tools: bool = True,
+        use_cache: bool = True,
+    ) -> "MCPConnection":
+
+        del_event = asyncio.Event()
+        opened_event = asyncio.Event()
+        con: MCPConnection = MCPConnection()
+        con.del_event = del_event
+
+        # That's a bit of a hack for closing the async context managers
+        async def lifecycle():
+            try:
+                logging.info(f"Connecting to MCP {url}...")
+                context_manager = streamablehttp_client(url)
+                (
+                    read_stream,
+                    write_stream,
+                    connection
+                ) = await context_manager.__aenter__()  # pylint: disable=E1101
+                con.url = url
+                con.read_stream = read_stream
+                con.write_stream = write_stream
+                con.connection = connection
+                con.context_manager = context_manager
+                await con.init_session()
+                if fetch_tools:
+                    await con.fetch_tools(use_cache=use_cache)
+                opened_event.set()
+                await del_event.wait()
+            finally:
+                await con.close()
+
+        asyncio.create_task(lifecycle())
+        await opened_event.wait()
+        return con
+
+    async def close(self):
+        logging.info(f"Closing MCP session ({self.url})...")
+        try:
+            if self.session:
+                await self.session.__aexit__(None, None, None)
+                del self.session
+                self.session = None
+        finally:
+            logging.info(f"Closing MCP connection ({self.url})...")
+            try:
+                if self.context_manager:
+                    await self.context_manager.__aexit__(None, None, None)
+                    del self.context_manager
+                    self.context_manager = None
+            finally:
+                logging.info(f"Closed CTX ({self.url})")
+
+    async def init_session(self):
+        logging.info(f"Initializing MCP session ({self.url})")
+        self.session = ClientSession(self.read_stream, self.write_stream)
+        await self.session.__aenter__()  # pylint: disable=unnecessary-dunder-call
+        await self.session.initialize()
+        return self.session
+
+    async def fetch_tools(self, use_cache: bool = True) -> "Tools":
+        if self.tools is not None:
+            return self.tools
+
+        if use_cache and (cached_tools := ToolsCache.read(self.url)):
+            logging.info("Using MCP tools from cache for %s", ui.green(self.url))
+            self.tools = cached_tools
+            return self.tools
+
+        logging.info("Fetching tools from MCP %s", ui.green(self.url))
+        mcp_tools = await self.session.list_tools()
+        self.tools = Tools.from_list([Tool.from_mcp(tool) for tool in mcp_tools.tools])
+        if use_cache:
+            ToolsCache.write(self.url, self.tools)
+        return self.tools
+
+    def __del__(self):
+        self.del_event.set()
+
+    async def exec(self, params: dict | LLMResponse):
+        if isinstance(params, LLMResponse):
+            try:
+                params = params.parse_json(
+                    raise_errors=True,
+                    required_fields=[env().config.AI_SYNTAX_FUNCTION_NAME_FIELD],
+                )
+            except BadAIJsonAnswer as e:
+                raise WrongMcpUsage(str(e)) from e
+        params = dict(params)
+        name = params.pop(env().config.AI_SYNTAX_FUNCTION_NAME_FIELD)
+        if not name:
+            raise WrongMcpUsage(
+                f"Tool name should be passed in {env().config.AI_SYNTAX_FUNCTION_NAME_FIELD} field"
+            )
+        logging.info(f"Calling MCP tool {ui.green(name)} with {params}...")
+        result = await self.session.call_tool(name, params)
+        content = result.content
+        if content and len(content) == 1 and content[0].type == "text":
+            return ExtendedString(content[0].text, result.__dict__)
+        return result
+
+
+@dataclass
+class Tool:
+    @dataclass
+    class Arg:
+        name: str = field()
+        description: str = field(default="")
+        type: str = field(default="string")
+        required: bool = field(default=...)
+        default: any = field(default=...)
+
+        def __post_init__(self):
+            if self.required is ...:
+                self.required = self.default is ...
+            if self.default is ...:
+                self.default = None
+
+    name: str = field()
+    description: str = field(default="")
+    args: dict[str, Arg | dict] = field(default_factory=dict)
+
+    def __post_init__(self):
+        for key in self.args.keys():  # pylint: disable=C0201, C0206
+            if isinstance(self.args[key], dict):
+                self.args[key] = Tool.Arg(**self.args[key])
+
+    @staticmethod
+    def from_mcp(tool: types.Tool) -> "Tool":
+        t = Tool(
+            name=tool.name,
+            description=tool.description,
+        )
+        for param_name, data in tool.inputSchema.get("properties", {}).items():
+            param = Tool.Arg(
+                name=param_name,
+                description=data.get("title", ""),
+                type=data.get("type", "string"),
+                required=param_name in tool.inputSchema.get("required", []),
+                default="",
+            )
+            t.args[param_name] = param
+        return t
+
+    def describe(self, syntax: AiFuncSyntax = None) -> str:
+        syntax = syntax or AiFuncSyntax.DEFAULT
+        tpl_file = f"ai-func.{syntax}.j2" if syntax in AiFuncSyntax else syntax
+        metadata = self._get_metadata()
+        return env().tpl_function(tpl_file, **metadata)
+
+    def _get_metadata(self):
+        return dict(
+            name=self.name,
+            description=self.description,
+            args={
+                arg.name: dict(
+                    default="NOT_SET" if arg.required else arg.default,
+                    type=arg.type,
+                    comment=arg.description,  # @todo rename it to description
+                )
+                for arg in self.args.values()
+            }
+        )
+
+    def __str__(self):
+        return self.describe(syntax=AiFuncSyntax.DEFAULT)
+
+
+class Tools(dict[str, Tool]):
+    def __str__(self):
+        return "\n".join([str(tool) for tool in self.values()])
+
+    @staticmethod
+    def from_list(tools: list[Tool]) -> "Tools":
+        return Tools({tool.name: tool for tool in tools})
+
+
+@dataclass
+class MCPServer:
+    name: str
+    url: str
+    tools: Tools = field(default_factory=Tools)
+
+    async def connect(
+        self,
+        fetch_tools: bool = True,
+        use_cache: bool = True,
+    ) -> MCPConnection:
+        return await MCPConnection.init(self.url, fetch_tools=fetch_tools, use_cache=use_cache)
+
+
+class MCPRegistry(dict[str, MCPServer]):
+    def __init__(self, server_configs: list[dict]):
+        super().__init__()
+        for server_config in server_configs:
+            self[server_config["name"]] = MCPServer(**server_config)
+
+    def get(self, server_name: str) -> MCPServer:
+        if server_name not in self:
+            raise ValueError(f"MCP server '{server_name}' not found in registry")
+        return self[server_name]
+
+    async def connect_to(
+        self,
+        server_name: str,
+        fetch_tools: bool = True,
+        use_cache: bool = True,
+    ) -> MCPConnection:
+        mcp_server = self.get(server_name)
+        return await mcp_server.connect(fetch_tools=fetch_tools, use_cache=use_cache)
+
+
+def server(name: str) -> MCPServer:
+    """
+    Returns MCP server by name from the registry.
+
+    Args:
+        name (str): The name of the MCP server.
+
+    Returns:
+        MCPServer: The MCP server instance.
+
+    Raises:
+        ValueError: If the server with the given name is not found in the registry.
+    """
+    return env().mcp_registry.get(name)

ai_microcore-4.0.0.dev12/microcore/templating/jinja2.py

@@ -0,0 +1,28 @@
+import os
+from pathlib import Path
+
+import jinja2
+from ..types import TplFunctionType
+
+
+def make_jinja2_env(env) -> jinja2.Environment:
+    j2 = jinja2.Environment(
+        autoescape=env.config.JINJA2_AUTO_ESCAPE,
+        loader=jinja2.ChoiceLoader([
+            jinja2.FileSystemLoader(env.config.PROMPT_TEMPLATES_PATH),
+            jinja2.FileSystemLoader(Path(__file__).parent.parent / "ai_func"),
+        ]),
+    )
+    j2.globals.update(
+        env=env,
+        config=env.config,
+        **env.config.JINJA2_GLOBALS,
+    )
+    return j2
+
+
+def make_tpl_function(env) -> TplFunctionType:
+    def tpl(file: os.PathLike[str] | str, **kwargs) -> str:
+        return env.jinja_env.get_template(file).render(**kwargs)
+
+    return tpl

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/utils.py

@@ -16,8 +16,9 @@ import tiktoken
 from colorama import Fore
 
 from .configuration import Config
-from .types import BadAIAnswer
+from .types import BadAIAnswer, BadAIJsonAnswer
 from .message_types import UserMsg, SysMsg, AssistantMsg
+from .json_parsing import parse_json
 
 
 def is_chat_model(model: str, config: Config = None) -> bool:
@@ -101,6 +102,18 @@ class ExtendedString(str):
         """
         return len(self.to_tokens(for_model=for_model, encoding=encoding))
 
+    def parse_json(
+        self, raise_errors: bool = True, required_fields: list[str] = None
+    ) -> list | dict | float | int | str:
+        return parse_json(self, raise_errors, required_fields)
+
+    def contains_valid_json(self) -> bool:
+        try:
+            self.parse_json(raise_errors=True)
+            return True
+        except BadAIJsonAnswer:
+            return False
+
 
 class DataclassEncoder(json.JSONEncoder):
     """@private"""

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/microcore/wrappers/llm_response_wrapper.py

@@ -1,10 +1,13 @@
 from typing import Any
+from typing import TYPE_CHECKING
 
 from ..types import BadAIAnswer, TPrompt
-from ..json_parsing import parse_json
 from ..utils import ExtendedString, ConvertableToMessage, extract_number
 from ..message_types import Role, AssistantMsg
 
+if TYPE_CHECKING:
+    from ..mcp import MCPConnection
+
 
 class DictFromLLMResponse(dict):
     llm_response: "LLMResponse"
@@ -13,6 +16,9 @@ class DictFromLLMResponse(dict):
         self.llm_response = llm_response
         return self
 
+    async def to_mcp(self, mcp: "MCPConnection"):
+        return await mcp.exec(self)
+
 
 class LLMResponse(ExtendedString, ConvertableToMessage):
     """
@@ -52,7 +58,7 @@ class LLMResponse(ExtendedString, ConvertableToMessage):
         validator: callable = None,
     ) -> list | dict | float | int | str | DictFromLLMResponse:
         try:
-            res = parse_json(self.content, True, required_fields)
+            res = super().parse_json(raise_errors=True, required_fields=required_fields)
             if validator:
                 try:
                     validator(res)
@@ -83,3 +89,6 @@ class LLMResponse(ExtendedString, ConvertableToMessage):
 
     def as_message(self) -> AssistantMsg:
         return self.as_assistant
+
+    async def to_mcp(self, mcp: "MCPConnection"):
+        return await mcp.exec(self)

{ai_microcore-4.0.0.dev11 → ai_microcore-4.0.0.dev12}/pyproject.toml

@@ -5,11 +5,13 @@ build-backend = "flit_core.buildapi"
 [project]
 name = "ai-microcore"
 dynamic = ["description", "version"]
-keywords = ["llm", "large language models", "ai", "similarity search", "ai search", "gpt", "openai"]
+keywords = ["llm", "large language models", "ai", "similarity search", "ai search", "gpt", "openai", "framework", "adapter"]
 readme = "README.md"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Intended Audience :: Developers",
@@ -24,6 +26,7 @@ dependencies = [
     "PyYAML~=6.0",
     "chardet~=5.2.0",
     "tiktoken>=0.7.0,<1.0",
+    "mcp~=1.9.1"
 ]
 requires-python = ">=3.10"
 

ai_microcore-4.0.0.dev11/microcore/templating/jinja2.py

@@ -1,19 +0,0 @@
-import os
-import jinja2
-from ..types import TplFunctionType
-
-
-def make_jinja2_env(env) -> jinja2.Environment:
-    return jinja2.Environment(
-        autoescape=env.config.JINJA2_AUTO_ESCAPE,
-        loader=jinja2.ChoiceLoader(
-            [jinja2.FileSystemLoader(env.config.PROMPT_TEMPLATES_PATH)]
-        ),
-    )
-
-
-def make_tpl_function(env) -> TplFunctionType:
-    def tpl(file: os.PathLike[str] | str, **kwargs) -> str:
-        return env.jinja_env.get_template(file).render(**kwargs)
-
-    return tpl