lionagi 0.17.3__tar.gz → 0.17.5__tar.gz

{lionagi-0.17.3 → lionagi-0.17.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.17.3
+Version: 0.17.5
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -330,8 +330,8 @@ from pydantic import BaseModel
 class Joke(BaseModel):
     joke: str
 
-res = await hunter.communicate(
-    "Tell me a short dragon joke",
+res = await hunter.operate(
+    instruction="Tell me a short dragon joke",
     response_format=Joke
 )
 print(type(res))
@@ -374,6 +374,33 @@ print(result)
 The LLM can now open the PDF, read in slices, fetch references, and produce a
 final structured summary.
 
+### MCP (Model Context Protocol) Integration
+
+LionAGI supports Anthropic's Model Context Protocol for seamless tool integration:
+
+```
+pip install "lionagi[mcp]"
+```
+
+```python
+from lionagi import load_mcp_tools
+
+# Load tools from any MCP server
+tools = await load_mcp_tools(".mcp.json", ["search", "memory"])
+
+# Use with ReAct reasoning
+branch = Branch(chat_model=gpt4o, tools=tools)
+result = await branch.ReAct(
+    instruct={"instruction": "Research recent AI developments"},
+    tools=["search_exa_search"],
+    max_extensions=3
+)
+```
+
+- **Dynamic Discovery**: Auto-discover and register tools from MCP servers
+- **Type Safety**: Full Pydantic validation for tool interactions
+- **Connection Pooling**: Efficient resource management with automatic reuse
+
 ### Observability & Debugging
 
 - Inspect messages:

{lionagi-0.17.3 → lionagi-0.17.5}/README.md

@@ -66,8 +66,8 @@ from pydantic import BaseModel
 class Joke(BaseModel):
     joke: str
 
-res = await hunter.communicate(
-    "Tell me a short dragon joke",
+res = await hunter.operate(
+    instruction="Tell me a short dragon joke",
     response_format=Joke
 )
 print(type(res))
@@ -110,6 +110,33 @@ print(result)
 The LLM can now open the PDF, read in slices, fetch references, and produce a
 final structured summary.
 
+### MCP (Model Context Protocol) Integration
+
+LionAGI supports Anthropic's Model Context Protocol for seamless tool integration:
+
+```
+pip install "lionagi[mcp]"
+```
+
+```python
+from lionagi import load_mcp_tools
+
+# Load tools from any MCP server
+tools = await load_mcp_tools(".mcp.json", ["search", "memory"])
+
+# Use with ReAct reasoning
+branch = Branch(chat_model=gpt4o, tools=tools)
+result = await branch.ReAct(
+    instruct={"instruction": "Research recent AI developments"},
+    tools=["search_exa_search"],
+    max_extensions=3
+)
+```
+
+- **Dynamic Discovery**: Auto-discover and register tools from MCP servers
+- **Type Safety**: Full Pydantic validation for tool interactions
+- **Connection Pooling**: Efficient resource management with automatic reuse
+
 ### Observability & Debugging
 
 - Inspect messages:

lionagi-0.17.5/lionagi/__init__.py

@@ -0,0 +1,96 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from typing import TYPE_CHECKING
+
+from . import ln as ln  # Lightweight concurrency utilities
+from .version import __version__
+
+if TYPE_CHECKING:
+    # Type hints only - not imported at runtime
+    from pydantic import BaseModel, Field
+
+    from .operations.node import Operation
+    from .service.imodel import iModel
+    from .session.session import Branch, Session
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# Module-level lazy loading cache
+_lazy_imports = {}
+
+
+def __getattr__(name: str):
+    """Lazy loading for expensive imports."""
+    if name in _lazy_imports:
+        return _lazy_imports[name]
+
+    # Lazy load core components
+    if name == "Session":
+        from .session.session import Session
+
+        _lazy_imports[name] = Session
+        return Session
+    elif name == "Branch":
+        from .session.session import Branch
+
+        _lazy_imports[name] = Branch
+        return Branch
+    # Lazy load Pydantic components
+    elif name == "BaseModel":
+        from pydantic import BaseModel
+
+        _lazy_imports[name] = BaseModel
+        return BaseModel
+    elif name == "Field":
+        from pydantic import Field
+
+        _lazy_imports[name] = Field
+        return Field
+    # Lazy load operations
+    elif name == "Operation":
+        from .operations.node import Operation
+
+        _lazy_imports[name] = Operation
+        return Operation
+    elif name == "iModel":
+        from .service.imodel import iModel
+
+        _lazy_imports[name] = iModel
+        return iModel
+    elif name == "types":
+        from . import _types as types
+
+        _lazy_imports["types"] = types
+        return types
+    elif name == "Builder":
+        from .operations.builder import OperationGraphBuilder as Builder
+
+        _lazy_imports["Builder"] = Builder
+        return Builder
+    elif name == "load_mcp_tools":
+        from .protocols.action.manager import load_mcp_tools
+
+        _lazy_imports["load_mcp_tools"] = load_mcp_tools
+        return load_mcp_tools
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+__all__ = (
+    "Session",
+    "Branch",
+    "iModel",
+    "types",
+    "__version__",
+    "BaseModel",
+    "Field",
+    "logger",
+    "Builder",
+    "Operation",
+    "load_mcp_tools",
+    "ln",
+)

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/ln/_async_call.py

@@ -5,7 +5,6 @@ from typing import Any, ClassVar
 
 import anyio
 import anyio.to_thread
-from pydantic import BaseModel
 
 from ._to_list import to_list
 from .concurrency import Lock as ConcurrencyLock
@@ -18,6 +17,10 @@ from .concurrency import (
 )
 from .types import Params, T, Unset, not_sentinel
 
+_INITIALIZED = False
+_MODEL_LIKE = None
+
+
 __all__ = (
     "alcall",
     "bcall",
@@ -54,6 +57,14 @@ async def alcall(
     retries, timeout, and output processing.
     """
 
+    global _INITIALIZED, _MODEL_LIKE
+    if _INITIALIZED is False:
+        from msgspec import Struct
+        from pydantic import BaseModel
+
+        _MODEL_LIKE = (BaseModel, Struct)
+        _INITIALIZED = True
+
     # Validate func is a single callable
     if not callable(func):
         # If func is not callable, maybe it's an iterable. Extract one callable if possible.
@@ -82,7 +93,7 @@ async def alcall(
     else:
         if not isinstance(input_, list):
             # Attempt to iterate
-            if isinstance(input_, BaseModel):
+            if isinstance(input_, _MODEL_LIKE):
                 # Pydantic model, convert to list
                 input_ = [input_]
             else:

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/ln/_hash.py

@@ -3,10 +3,13 @@ from __future__ import annotations
 import copy
 
 import msgspec
-from pydantic import BaseModel as PydanticBaseModel
 
 __all__ = ("hash_dict",)
 
+# Global initialization state
+_INITIALIZED = False
+PydanticBaseModel = None
+
 # --- Canonical Representation Generator ---
 _PRIMITIVE_TYPES = (str, int, float, bool, type(None))
 _TYPE_MARKER_DICT = 0
@@ -35,7 +38,7 @@ def _generate_hashable_representation(item: any) -> any:
             _generate_hashable_representation(msgspec.to_builtins(item)),
         )
 
-    if isinstance(item, PydanticBaseModel):
+    if PydanticBaseModel and isinstance(item, PydanticBaseModel):
         # Process the Pydantic model by first dumping it to a dict, then processing that dict.
         # The type marker distinguishes this from a regular dictionary.
         return (
@@ -117,6 +120,13 @@ def _generate_hashable_representation(item: any) -> any:
 
 
 def hash_dict(data: any, strict: bool = False) -> int:
+    global _INITIALIZED, PydanticBaseModel
+    if _INITIALIZED is False:
+        from pydantic import BaseModel
+
+        PydanticBaseModel = BaseModel
+        _INITIALIZED = True
+
     data_to_process = data
     if strict:
         data_to_process = copy.deepcopy(data)

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/ln/_to_list.py

@@ -3,24 +3,20 @@ from dataclasses import dataclass
 from enum import Enum as _Enum
 from typing import Any, ClassVar
 
-from msgspec import Struct
-from pydantic import BaseModel
-from pydantic_core import PydanticUndefinedType
-
 from ._hash import hash_dict
-from .types import Params, UndefinedType, UnsetType
+from .types import Params
 
 __all__ = ("to_list", "ToListParams")
 
 
+_INITIALIZED = False
+_MODEL_LIKE = None
+_MAP_LIKE = None
+_SINGLETONE_TYPES = None
+_SKIP_TYPE = None
+_SKIP_TUPLE_SET = None
 _BYTE_LIKE = (str, bytes, bytearray)
-_MODEL_LIKE = (BaseModel, Struct)
-_MAP_LIKE = (Mapping, *_MODEL_LIKE)
 _TUPLE_SET = (tuple, set, frozenset)
-_SINGLETONE_TYPES = (UndefinedType, UnsetType, PydanticUndefinedType)
-
-_SKIP_TYPE = (*_BYTE_LIKE, *_MAP_LIKE, _Enum)
-_SKIP_TUPLE_SET = (*_SKIP_TYPE, *_TUPLE_SET)
 
 
 def to_list(
@@ -50,6 +46,21 @@ def to_list(
     Raises:
         ValueError: If unique=True is used without flatten=True.
     """
+    global _INITIALIZED
+    if _INITIALIZED is False:
+        from msgspec import Struct
+        from pydantic import BaseModel
+        from pydantic_core import PydanticUndefinedType
+
+        from .types import UndefinedType, UnsetType
+
+        global _MODEL_LIKE, _MAP_LIKE, _SINGLETONE_TYPES, _SKIP_TYPE, _SKIP_TUPLE_SET
+        _MODEL_LIKE = (BaseModel, Struct)
+        _MAP_LIKE = (Mapping, *_MODEL_LIKE)
+        _SINGLETONE_TYPES = (UndefinedType, UnsetType, PydanticUndefinedType)
+        _SKIP_TYPE = (*_BYTE_LIKE, *_MAP_LIKE, _Enum)
+        _SKIP_TUPLE_SET = (*_SKIP_TYPE, *_TUPLE_SET)
+        _INITIALIZED = True
 
     def _process_list(
         lst: list[Any],
@@ -117,7 +128,7 @@ def to_list(
                 else [input_]
             )
 
-        if isinstance(input_, BaseModel):
+        if isinstance(input_, _MODEL_LIKE):
             return [input_]
 
         if isinstance(input_, Iterable) and not isinstance(input_, _BYTE_LIKE):

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/ln/fuzzy/_fuzzy_validate.py

@@ -1,7 +1,5 @@
 from collections.abc import Callable, Sequence
-from typing import Any, Literal
-
-from pydantic import BaseModel
+from typing import TYPE_CHECKING, Any, Literal
 
 from lionagi._errors import ValidationError
 
@@ -11,13 +9,17 @@ from ._fuzzy_match import FuzzyMatchKeysParams, fuzzy_match_keys
 from ._string_similarity import SIMILARITY_TYPE
 from ._to_dict import to_dict
 
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+
 __all__ = ("fuzzy_validate_pydantic",)
 
 
 def fuzzy_validate_pydantic(
     text,
     /,
-    model_type: type[BaseModel],
+    model_type: "type[BaseModel]",
     fuzzy_parse: bool = True,
     fuzzy_match: bool = False,
     fuzzy_match_params: FuzzyMatchKeysParams | dict = None,

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/protocols/action/manager.py

@@ -12,8 +12,6 @@ from lionagi.utils import to_list
 from .function_calling import FunctionCalling
 from .tool import FuncTool, FuncToolRef, Tool, ToolRef
 
-__all__ = ("ActionManager",)
-
 
 class ActionManager(Manager):
     """

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/service/connections/api_calling.py

@@ -85,20 +85,16 @@ class APICalling(Event):
                 TOKEN_LIMITS = {
                     # OpenAI models
                     "gpt-4": 128_000,
-                    "gpt-4-turbo": 128_000,
-                    "o1-mini": 128_000,
-                    "o1-preview": 128_000,
                     "o1": 200_000,
                     "o3": 200_000,
                     "gpt-4.1": 1_000_000,
+                    "gpt-5": 1_000_000,
                     # Anthropic models
                     "sonnet": 200_000,
                     "haiku": 200_000,
                     "opus": 200_000,
                     # Google models
                     "gemini": 1_000_000,
-                    # Alibaba models
-                    "qwen-turbo": 1_000_000,
                 }
 
                 token_msg = (

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/service/connections/mcp/wrapper.py

@@ -7,15 +7,7 @@ import json
 import logging
 import os
 from pathlib import Path
-from typing import Any, Dict
-
-try:
-    from fastmcp import Client as FastMCPClient
-
-    FASTMCP_AVAILABLE = True
-except ImportError:
-    FASTMCP_AVAILABLE = False
-    FastMCPClient = None
+from typing import Any
 
 # Suppress MCP server logging by default
 logging.getLogger("mcp").setLevel(logging.WARNING)
@@ -88,11 +80,6 @@ class MCPConnectionPool:
     @classmethod
     async def get_client(cls, server_config: dict[str, Any]) -> Any:
         """Get or create a pooled MCP client."""
-        if not FASTMCP_AVAILABLE:
-            raise ImportError(
-                "FastMCP not installed. Run: pip install fastmcp"
-            )
-
         # Generate unique key for this config
         if "server" in server_config:
             # Server reference from .mcp.json
@@ -149,6 +136,13 @@ class MCPConnectionPool:
         if not any(k in config for k in ["url", "command"]):
             raise ValueError("Config must have either 'url' or 'command' key")
 
+        try:
+            from fastmcp import Client as FastMCPClient
+        except ImportError:
+            raise ImportError(
+                "FastMCP not installed. Run: pip install fastmcp"
+            )
+
         # Handle different config formats
         if "url" in config:
             # Direct URL connection
@@ -172,7 +166,6 @@ class MCPConnectionPool:
                 # Common environment variables to suppress logging
                 env.setdefault("LOG_LEVEL", "ERROR")
                 env.setdefault("PYTHONWARNINGS", "ignore")
-                env.setdefault("KHIVEMCP_LOG_LEVEL", "ERROR")
                 # Suppress FastMCP server logs
                 env.setdefault("FASTMCP_QUIET", "true")
                 env.setdefault("MCP_QUIET", "true")

{lionagi-0.17.3 → lionagi-0.17.5}/lionagi/utils.py

@@ -87,8 +87,6 @@ __all__ = (
     "max_concurrent",
     "force_async",
     "breakdown_pydantic_annotation",
-    "run_package_manager_command",
-    "StringEnum",
     "Enum",
     "hash_dict",
     "is_union_type",
@@ -106,12 +104,6 @@ __all__ = (
 )
 
 
-# --- General Global Utilities Types ---
-@deprecated("String Enum is deprecated, use `Enum` instead.")
-class StringEnum(str, Enum):
-    pass
-
-
 # --- General Global Utilities Functions ---
 def time(
     *,

lionagi-0.17.5/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.17.5"

{lionagi-0.17.3 → lionagi-0.17.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.17.3"
+version = "0.17.5"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },