ai-microcore 4.0.0.dev23__tar.gz → 4.2.0__tar.gz

{ai_microcore-4.0.0.dev23 → ai_microcore-4.2.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: ai-microcore
-Version: 4.0.0.dev23
+Version: 4.2.0
 Summary: # Minimalistic Foundation for AI Applications
 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>
+Author-email: Vitalii Stepanenko <mail@vitaliy.in>
+Maintainer-email: Vitalii Stepanenko <mail@vitaliy.in>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
@@ -26,13 +26,14 @@ Requires-Dist: tiktoken>=0.7.0,<1.0
 Requires-Dist: mcp~=1.9.2
 Requires-Dist: fastmcp~=2.8.0
 Requires-Dist: docstring_parser~=0.16.0
+Requires-Dist: httpx~=0.28.1
 Project-URL: Source Code, https://github.com/Nayjest/ai-microcore
 
 <p align="right"> 
     <a href="https://github.com/Nayjest/ai-microcore/releases" target="_blank"><img src="https://img.shields.io/github/v/release/Nayjest/ai-microcore.svg" alt="Release Notes"></a>
     <a href="https://app.codacy.com/gh/Nayjest/ai-microcore/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade" target="_blank"><img src="https://app.codacy.com/project/badge/Grade/441d03416bc048828c649129530dcbc3" alt="Code Quality"></a>
     <a href="https://github.com/Nayjest/ai-microcore/actions/workflows/pylint.yml" target="_blank"><img src="https://github.com/Nayjest/ai-microcore/actions/workflows/pylint.yml/badge.svg" alt="Pylint"></a>
-    <img src="https://github.com/Nayjest/ai-microcore/blob/main/coverage.svg" alt="Code Coverage">
+    <img src="https://raw.githubusercontent.com/Nayjest/ai-microcore/main/coverage.svg" alt="Code Coverage">
     <a href="https://github.com/Nayjest/ai-microcore/actions/workflows/tests.yml" target="_blank"><img src="https://github.com/Nayjest/ai-microcore/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
     <a href="https://github.com/Nayjest/ai-microcore/blob/main/LICENSE" target="_blank"><img src="https://img.shields.io/static/v1?label=license&message=MIT&color=d08aff" alt="License"></a>
 </p>
@@ -142,8 +143,10 @@ See [transformers installation](https://huggingface.co/docs/transformers/install
 ### Vector Databases
 
 Vector database functions are available via `microcore.texts`.
+
+#### ChromaDB
 Default vector database is [Chroma](https://www.trychroma.com/).
-In order to use vector database functions, you need to install the `chromadb` package:
+In order to use vector database functions with ChromaDB, you need to install the `chromadb` package:
 ```bash
 pip install chromadb
 ```
@@ -157,6 +160,25 @@ configure(
     EMBEDDING_DB_PORT = 8000,
 )
 ```
+#### Qdrant
+In order to use vector database functions with Qdrant, you need to install the `qdrant-client` package:
+```bash
+pip install qdrant-client
+```
+Configuration example
+```python
+from microcore import configure, EmbeddingDbType
+from sentence_transformers import SentenceTransformer
+
+configure(
+    EMBEDDING_DB_TYPE=EmbeddingDbType.QDRANT,
+    EMBEDDING_DB_HOST="localhost",
+    EMBEDDING_DB_PORT="6333",
+    EMBEDDING_DB_SIZE=384,  # dimentions quantity in used SentenceTransformer model
+    EMBEDDING_DB_FUNCTION=SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2"),
+)
+```
+
 
 ## 🌟 Core Functions
 

{ai_microcore-4.0.0.dev23 → ai_microcore-4.2.0}/README.md

@@ -2,7 +2,7 @@
     <a href="https://github.com/Nayjest/ai-microcore/releases" target="_blank"><img src="https://img.shields.io/github/v/release/Nayjest/ai-microcore.svg" alt="Release Notes"></a>
     <a href="https://app.codacy.com/gh/Nayjest/ai-microcore/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade" target="_blank"><img src="https://app.codacy.com/project/badge/Grade/441d03416bc048828c649129530dcbc3" alt="Code Quality"></a>
     <a href="https://github.com/Nayjest/ai-microcore/actions/workflows/pylint.yml" target="_blank"><img src="https://github.com/Nayjest/ai-microcore/actions/workflows/pylint.yml/badge.svg" alt="Pylint"></a>
-    <img src="https://github.com/Nayjest/ai-microcore/blob/main/coverage.svg" alt="Code Coverage">
+    <img src="https://raw.githubusercontent.com/Nayjest/ai-microcore/main/coverage.svg" alt="Code Coverage">
     <a href="https://github.com/Nayjest/ai-microcore/actions/workflows/tests.yml" target="_blank"><img src="https://github.com/Nayjest/ai-microcore/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
     <a href="https://github.com/Nayjest/ai-microcore/blob/main/LICENSE" target="_blank"><img src="https://img.shields.io/static/v1?label=license&message=MIT&color=d08aff" alt="License"></a>
 </p>
@@ -112,8 +112,10 @@ See [transformers installation](https://huggingface.co/docs/transformers/install
 ### Vector Databases
 
 Vector database functions are available via `microcore.texts`.
+
+#### ChromaDB
 Default vector database is [Chroma](https://www.trychroma.com/).
-In order to use vector database functions, you need to install the `chromadb` package:
+In order to use vector database functions with ChromaDB, you need to install the `chromadb` package:
 ```bash
 pip install chromadb
 ```
@@ -127,6 +129,25 @@ configure(
     EMBEDDING_DB_PORT = 8000,
 )
 ```
+#### Qdrant
+In order to use vector database functions with Qdrant, you need to install the `qdrant-client` package:
+```bash
+pip install qdrant-client
+```
+Configuration example
+```python
+from microcore import configure, EmbeddingDbType
+from sentence_transformers import SentenceTransformer
+
+configure(
+    EMBEDDING_DB_TYPE=EmbeddingDbType.QDRANT,
+    EMBEDDING_DB_HOST="localhost",
+    EMBEDDING_DB_PORT="6333",
+    EMBEDDING_DB_SIZE=384,  # dimentions quantity in used SentenceTransformer model
+    EMBEDDING_DB_FUNCTION=SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2"),
+)
+```
+
 
 ## 🌟 Core Functions
 

{ai_microcore-4.0.0.dev23 → ai_microcore-4.2.0}/microcore/__init__.py

@@ -186,4 +186,4 @@ __all__ = [
     # "wrappers",
 ]
 
-__version__ = "4.0.0-dev23"
+__version__ = "4.2.0"

ai_microcore-4.2.0/microcore/_mcp.py

@@ -0,0 +1,381 @@
+import asyncio
+import logging
+import datetime
+from typing import Optional, Dict, Any
+from dataclasses import dataclass, field
+from enum import Enum
+
+import requests
+from fastmcp import Client
+from fastmcp.client.progress import ProgressHandler
+import mcp.types
+
+from .utils import ExtendedString, ConvertableToMessage
+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)
+
+    @staticmethod
+    def clear():
+        logging.info("Clearing MCP tools cache...")
+        storage.delete(ToolsCache.FILE)
+
+
+class MCPAnswer(ExtendedString, ConvertableToMessage):
+    ...
+
+
+class McpTransport(str, Enum):
+    SSE: str = "sse"
+    STREAMABLE_HTTP: str = "streamable_http"
+    WS: str = "ws"
+    STDIO: str = "stdio"
+
+    def __str__(self):
+        return self.value
+
+
+@dataclass
+class MCPConnection:
+    url: str = None
+    transport: McpTransport = field(default=McpTransport.STREAMABLE_HTTP)
+    headers: Optional[Dict[str, str]] = field(default_factory=dict)
+    tools: Optional["Tools"] = field(default=None, init=False)
+    _client: Client | None = field(default=None, init=False)
+
+    @staticmethod
+    async def init(
+        url: str,
+        transport: McpTransport,
+        headers: Optional[Dict[str, str]] = None,
+        fetch_tools: bool = True,
+        use_cache: bool = True,
+        connect_timeout: float = 10,
+    ) -> "MCPConnection":
+        con: MCPConnection = MCPConnection(url=url, transport=transport, headers=headers)
+        con._client = Client(url, timeout=connect_timeout, headers=headers)  # pylint: disable=W0212
+        await con._client.__aenter__()  # pylint: disable=E1101,W0212,C2801
+        if fetch_tools:
+            await con.fetch_tools(use_cache=use_cache)
+        return con
+
+    async def close(self):
+        if self._client:
+            await self._client.__aexit__(None, None, None)
+            self._client = None
+        else:
+            logging.error(f"Trying to close MCP connection that is not opened ({self.url})")
+
+    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._client.list_tools()
+        self.tools = Tools.from_list([Tool.from_mcp(tool) for tool in mcp_tools])
+        if use_cache:
+            self.update_tools_cache()
+        return self.tools
+
+    def update_tools_cache(self):
+        if self.tools is None:
+            raise RuntimeError("Tools are not fetched yet. Call fetch_tools() first.")
+        ToolsCache.write(self.url, self.tools)
+
+    async def call(
+        self,
+        name: str,
+        timeout: datetime.timedelta | float | int | None = None,
+        progress_handler: ProgressHandler | None = None,
+        **kwargs
+    ):
+        assert env().config.AI_SYNTAX_FUNCTION_NAME_FIELD not in kwargs
+        params = dict(kwargs)
+        params[env().config.AI_SYNTAX_FUNCTION_NAME_FIELD] = name
+        return await self.exec(params, timeout=timeout, progress_handler=progress_handler)
+
+    async def exec(
+        self,
+        params: dict | LLMResponse,
+        timeout: datetime.timedelta | float | int | None = None,
+        progress_handler: ProgressHandler | None = None,
+    ):
+        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}...")
+        content = await self._client.call_tool(
+            name=name,
+            arguments=params,
+            timeout=timeout,
+            progress_handler=progress_handler
+        )
+        if content and len(content) == 1 and content[0].type == "text":
+            return MCPAnswer(content[0].text, dict(response=content))
+        return content
+
+
+@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: mcp.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:
+    url: str
+    name: str = field(default="")
+    auth_token: Optional[str] = field(default=None)
+    headers: Optional[Dict[str, str]] = field(default=None)
+    tools: Tools = field(default_factory=Tools)
+    transport: McpTransport = field(default=None)
+
+    @staticmethod
+    def _try_sse_or_streamable_http(url, headers=None) -> tuple[McpTransport, str]:
+        if url.endswith("/"):
+            test_sse_url = f"{url}sse"
+        else:
+            test_sse_url = f"{url}/sse"
+        try:
+            request_headers = headers or {}
+            response = requests.request(
+                method="HEAD",
+                url=test_sse_url,
+                headers=request_headers,
+                timeout=5
+            )
+            if response.status_code == 200:
+                return McpTransport.SSE, test_sse_url
+        except requests.RequestException:
+            # not a SSE endpoint or not reachable
+            pass
+        return McpTransport.STREAMABLE_HTTP, f"{url}/mcp"
+
+    @staticmethod
+    def _guess_transport_type_by_url(url: str) -> Optional[McpTransport]:
+        if url.startswith("ws://") or url.startswith("wss://"):
+            return McpTransport.WS
+        if url.endswith("/mcp"):
+            return McpTransport.STREAMABLE_HTTP
+        if url.endswith("/sse"):
+            return McpTransport.SSE
+        return None
+
+    @staticmethod
+    def name_from_url(url: str) -> str:
+        """Domain name from URL."""
+        return url.split("//")[-1].split("/")[0]
+
+    def __post_init__(self):
+        if not self.name:
+            self.name = MCPServer.name_from_url(self.url)
+        if not self.transport:
+            self.transport = self._guess_transport_type_by_url(self.url)
+
+        # Prepare headers with authentication if provided
+        if self.headers is None:
+            self.headers = {}
+
+        if self.auth_token:
+            self.headers["Authorization"] = f"Bearer {self.auth_token}"
+
+    async def connect(
+        self,
+        fetch_tools: bool = True,
+        use_cache: bool = True,
+        connect_timeout: float = 10,
+    ) -> MCPConnection:
+        if self.transport:
+            transport, url = self.transport, self.url
+        else:
+            transport, url = self._try_sse_or_streamable_http(self.url, self.headers)
+
+        return await MCPConnection.init(
+            url=url,
+            transport=transport,
+            auth_token=self.auth_token,
+            headers=self.headers,
+            fetch_tools=fetch_tools,
+            use_cache=use_cache,
+            connect_timeout=connect_timeout,
+        )
+
+    def get_tools_cache(self) -> Tools | None:
+        return ToolsCache.read(self.url)
+
+
+class MCPRegistry(dict[str, MCPServer]):
+    def __init__(self, server_configs: list[dict | str]):
+        super().__init__()
+        for server_config in server_configs:
+            if isinstance(server_config, str):
+                server_config = {
+                    "name": MCPServer.name_from_url(server_config),
+                    "url": server_config
+                }
+            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 precache_tools(
+        self,
+        raise_errors: bool = False,
+        connect_timeout: int = 10,
+    ):
+        async def precache_server_tools(server_name):
+            conn = None
+            try:
+                conn = await self.get(server_name).connect(
+                    fetch_tools=True,
+                    use_cache=False,
+                    connect_timeout=connect_timeout,
+                )
+                conn.update_tools_cache()
+            except Exception as e:  # pylint: disable=W0718
+                logging.error("Failed to precache tools for MCP server %s: %s", server_name, e)
+                if raise_errors:
+                    raise
+            finally:
+                if conn is not None:
+                    await conn.close()
+
+        await asyncio.gather(*[precache_server_tools(srv) for srv in self.keys()])
+
+    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.dev23 → ai_microcore-4.2.0}/microcore/embedding_db/qdrant.py

@@ -67,21 +67,55 @@ class QdrantEmbeddingDB(AbstractEmbeddingDB):
         )
 
     @classmethod
-    def _convert_where(cls, where: dict | None, kwargs=None) -> Filter | None:
+    def _convert_where(  # pylint: disable=too-many-branches
+        cls,
+        where: dict | None,
+        kwargs=None
+    ) -> Filter | None:
+        where_doc = kwargs and kwargs.get("where_document", {}).get("$contains", None)
+        if isinstance(where, Filter):
+            if where_doc:
+                raise ValueError(
+                    "Cannot use `where_document` with Filter object passed as `where` argument. "
+                    "Please use a dictionary instead."
+                )
+            return where
+
         conditions = []
+        _and = True
+        if where:
+            if "$or" in where:
+                _and = False
+                for i in where["$or"]:
+                    for k, v in i.items():
+                        conditions.append(FieldCondition(key=k, match=MatchValue(value=v)))
+            elif "$and" in where:
+                _and = True
+                for i in where["$and"]:
+                    for k, v in i.items():
+                        conditions.append(FieldCondition(key=k, match=MatchValue(value=v)))
+            else:
+                for k, v in where.items():
+                    conditions.append(FieldCondition(key=k, match=MatchValue(value=v)))
+
         # ChromaDB format
-        if kwargs and "where_document" in kwargs and kwargs["where_document"]:
+        if where_doc:
+            if not _and:
+                raise ValueError(
+                    "Cannot use `where_document` with `$or` condition. "
+                )
             conditions.append(
                 FieldCondition(
                     key="_text",
                     match=MatchText(text=kwargs["where_document"]["$contains"])
                 )
             )
-        if where:
-            for k, v in where.items():
-                conditions.append(FieldCondition(key=k, match=MatchValue(value=v)))
 
-        return Filter(must=conditions) if conditions else None
+        if not conditions:
+            return None
+        if _and:
+            return Filter(must=conditions)
+        return Filter(should=conditions)
 
     def search(
         self,

{ai_microcore-4.0.0.dev23 → ai_microcore-4.2.0}/microcore/logging.py

@@ -100,7 +100,7 @@ def _log_response(out):
 def use_logging():
     """Turns on logging of LLM requests and responses to console."""
     if not is_notebook():
-        init(autoreset=True, strip=False)
+        init(strip=False)
     if _log_request not in env().llm_before_handlers:
         env().llm_before_handlers.append(_log_request)
     if _log_response not in env().llm_after_handlers:

{ai_microcore-4.0.0.dev23 → ai_microcore-4.2.0}/microcore/mcp.py

@@ -5,6 +5,7 @@ from typing import Optional
 from dataclasses import dataclass, field
 from enum import Enum
 
+import httpx
 import requests
 from fastmcp import Client
 from fastmcp.client.progress import ProgressHandler
@@ -23,6 +24,16 @@ class WrongMcpUsage(BadAIAnswer):
     ...
 
 
+class HeaderAuth(httpx.Auth):
+    def __init__(self, header_name, header_value):
+        self.header_name = header_name
+        self.header_value = header_value
+
+    def auth_flow(self, request):
+        request.headers[self.header_name] = self.header_value
+        yield request
+
+
 class ToolsCache:
     FILE = "mcp/tools.json"
 
@@ -75,9 +86,14 @@ class MCPConnection:
         fetch_tools: bool = True,
         use_cache: bool = True,
         connect_timeout: float = 10,
+        auth: httpx.Auth = None,
     ) -> "MCPConnection":
         con: MCPConnection = MCPConnection(url=url, transport=transport)
-        con._client = Client(url, timeout=connect_timeout)  # pylint: disable=W0212
+        con._client = Client(
+            url,
+            timeout=connect_timeout,
+            auth=auth,
+        )  # pylint: disable=W0212
         await con._client.__aenter__()  # pylint: disable=E1101,W0212,C2801
         if fetch_tools:
             await con.fetch_tools(use_cache=use_cache)
@@ -236,6 +252,7 @@ class MCPServer:
     name: str = field(default="")
     tools: Tools = field(default_factory=Tools)
     transport: McpTransport = field(default=None)
+    auth: httpx.Auth | dict | None = field(default=None)
 
     @staticmethod
     def _try_sse_or_streamable_http(url) -> tuple[McpTransport, str]:
@@ -272,6 +289,12 @@ class MCPServer:
             self.name = MCPServer.name_from_url(self.url)
         if not self.transport:
             self.transport = self._guess_transport_type_by_url(self.url)
+        if self.auth and isinstance(self.auth, dict) and len(self.auth)==1:
+            header_name, header_value = next(iter(self.auth.items()))
+            self.auth = HeaderAuth(
+                header_name=header_name,
+                header_value=header_value
+            )
 
     async def connect(
         self,
@@ -289,6 +312,7 @@ class MCPServer:
             fetch_tools=fetch_tools,
             use_cache=use_cache,
             connect_timeout=connect_timeout,
+            auth=self.auth
         )
 
     def get_tools_cache(self) -> Tools | None:

{ai_microcore-4.0.0.dev23 → ai_microcore-4.2.0}/microcore/ui.py

@@ -2,7 +2,7 @@ from colorama import Fore, init
 from .utils import is_notebook
 
 if not is_notebook():
-    init(autoreset=True, strip=False)
+    init(strip=False)
 
 
 def info(*args, color=Fore.LIGHTYELLOW_EX, **kwargs):

{ai_microcore-4.0.0.dev23 → ai_microcore-4.2.0}/pyproject.toml

@@ -29,14 +29,15 @@ dependencies = [
     "mcp~=1.9.2",
     "fastmcp~=2.8.0",
     "docstring_parser~=0.16.0",
+    "httpx~=0.28.1"
 ]
 requires-python = ">=3.10"
 
 authors = [
-    { name = "Vitalii Stepanenko", email = "mail@vitalii.in" },
+    { name = "Vitalii Stepanenko", email = "mail@vitaliy.in" },
 ]
 maintainers = [
-    { name = "Vitalii Stepanenko", email = "mail@vitalii.in" },
+    { name = "Vitalii Stepanenko", email = "mail@vitaliy.in" },
 ]
 license = { file = "LICENSE" }