lionagi 0.8.5__tar.gz → 0.8.7__tar.gz

{lionagi-0.8.5 → lionagi-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.8.5
+Version: 0.8.7
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -235,310 +235,134 @@ Description-Content-Type: text/markdown
 
 [Documentation](https://lion-agi.github.io/lionagi/) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
 
-# LION Framework
-### Language InterOperable Network - The Future of Controlled AI Operations
+# LION - Language InterOperable Network
 
-> Harness the power of next-generation AI while maintaining complete control and reliability.
+## An Intelligence Operating System
 
-## Why LION?
+LionAGI is a robust framework for orchestrating multi-step AI operations with precise control. Bring together multiple models, advanced ReAct reasoning, tool integrations, and custom validations in a single coherent pipeline.
 
-The AI revolution is transforming how we work - but with great power comes great responsibility. LION provides the control mechanisms and reliability features needed to safely integrate advanced AI capabilities into enterprise workflows.
-
-LION is designed to be:
-- 🔒 **Controlled**: Built-in safety mechanisms and verification
-- 🎯 **Precise**: Exact control over AI behaviors
-- 🔧 **Flexible**: Build any workflow you need
-- 🚀 **Efficient**: Minimal dependencies, maximum performance
+## Why LionAGI?
 
+- **Structured**: LLM interactions are validated and typed (via Pydantic).
+- **Expandable**: Integrate multiple providers (OpenAI, Anthropic, Perplexity, custom) with minimal friction.
+- **Controlled**: Built-in safety checks, concurrency strategies, and advanced multi-step flows—like ReAct with verbose outputs.
+- **Transparent**: Real-time logging, message introspection, and easy debugging of tool usage.
 
 
 ## Installation
 
-LION maintains minimal dependencies for maximum reliability:
-
-```bash
-uv pip install lionagi
+```
+pip install lionagi
 ```
 
 Dependencies:
-- litellm
-- jinja2
-- pandas
-- pillow
-- python-dotenv
-
+	•	litellm
+	•	jinja2
+	•	pandas
+	•	pillow
+	•	python-dotenv
 
 ## Quick Start
-
 ```python
-from lionagi import iModel, Branch
+from lionagi import Branch, iModel
 
-# Initialize model
-gpt4o = iModel(provider="openai", task="chat", model="gpt-4o")
+# Pick a model
+gpt4o = iModel(provider="openai", model="gpt-4o")
 
+# Create a Branch (conversation context)
 hunter = Branch(
-  system="you are a hilarious dragon hunter who responds in 10 words rhymes",
-  imodel=gpt4o,
+  system="you are a hilarious dragon hunter who responds in 10 words rhymes.",
+  chat_model=gpt4o,
 )
 
-# Chat asynchronously
-print(await hunter.communicate("I am a dragon"))
+# Communicate asynchronously
+response = await hunter.communicate("I am a dragon")
+print(response)
 ```
 
 ```
 You claim to be a dragon, oh what a braggin'!
 ```
+### Structured Responses
 
-## 📦 Features
-
-### 1. Model Agnostic Structured Output
-
-LION provides a unified interface for interacting with any AI model, regardless of the underlying architecture. This allows you to easily switch between models without changing your code.
+Use Pydantic to keep outputs structured:
 
 ```python
 from pydantic import BaseModel
 
 class Joke(BaseModel):
-  joke: str
+    joke: str
 
-sonnet = iModel(
-  provider="anthropic",
-  model="claude-3-5-sonnet-20241022",
-  max_tokens=100,                    # max_tokens is required for anthropic models
+res = await hunter.communicate(
+    "Tell me a short dragon joke",
+    response_format=Joke
 )
-
-response = await hunter.communicate(
-  instruction="I am a dragon",
-  response_format=Joke,           # structured output in given pydantic model
-  clear_messages=True,            # refresh the conversation
-  imodel=sonnet,                  # use sonnet model, which doesn't support structured output
-)
-
 print(type(response))
 print(response.joke)
 ```
-
 ```
 <class '__main__.Joke'>
-Joke(joke='With fiery claws, dragons hide their laughter flaws!')
+With fiery claws, dragons hide their laughter flaws!
 ```
 
+### ReAct and Tools
 
-### 2. Complete Observability
+LionAGI supports advanced multi-step reasoning with ReAct. Tools let the LLM invoke external actions:
 
 ```python
-# using perplexity model
-pplx_small = iModel(
-    provider="perplexity",
-    task="chat/completions",
-    model="llama-3.1-sonar-small-128k-online",
-    max_tokens=1000,
-)
-
-b = await hunter.communicate(
-    instruction="What makes a well-behaved dragon?",
-    clear_messages=True,            # refresh the conversation
-    imodel=pplx_small,              # use perplexity model
+from lionagi.tools.types import ReaderTool
+
+branch = Branch(chat_model=gpt4o, tools=ReaderTool)
+result = await branch.ReAct(
+    instruct={
+      "instruction": "Summarize my PDF and compare with relevant papers.",
+      "context": {"paper_file_path": "/path/to/paper.pdf"},
+    },
+    extension_allowed=True,     # allow multi-round expansions
+    max_extensions=5,
+    verbose=True,      # see step-by-step chain-of-thought
 )
-
-print(b)
-```
-
-```
-A well-behaved dragon is one that's calm and bright,
-No stress or fear, just a peaceful night.
-It's active, not lethargic, with a happy face,
-And behaviors like digging, not a frantic pace.
-It's social, friendly, and never a fright,
-Just a gentle soul, shining with delight
-```
-
-```python
-hunter.msgs.last_response.model_response
-```
-
-```
-{'id': '1be10f4c-0936-4050-ab48-91bd86ab11a5',
- 'model': 'llama-3.1-sonar-small-128k-online',
- 'object': 'chat.completion',
- 'created': 1734369700,
- 'choices': [{'index': 0,
-   'message': {'role': 'assistant',
-    'content': "A well-behaved dragon is one that's calm and bright,\nNo stress or fear, just a peaceful night.\nIt's active, not lethargic, with a happy face,\nAnd behaviors like digging, not a frantic pace.\nIt's social, friendly, and never a fright,\nJust a gentle soul, shining with delight"},
-   'finish_reason': 'stop',
-   'delta': {'role': 'assistant', 'content': ''}}],
- 'usage': {'prompt_tokens': 40, 'completion_tokens': 69, 'total_tokens': 109},
- 'citations': [{'url': 'https://dragonsdiet.com/blogs/dragon-care/15-bearded-dragon-behaviors-and-what-they-could-mean'},
-  {'url': 'https://masterbraeokk.tripod.com/dragons/behavior.html'},
-  {'url': 'https://files.eric.ed.gov/fulltext/ED247607.pdf'},
-  {'url': 'https://www.travelchinaguide.com/intro/social_customs/zodiac/dragon/five-elements.htm'},
-  {'url': 'https://www.travelchinaguide.com/intro/social_customs/zodiac/dragon/'}]}
+print(result)
 ```
 
+The LLM can now open the PDF, read in slices, fetch references, and produce a final structured summary.
 
-### 3. Easy composition of complex workflows
-
+### Observability & Debugging
+- Inspect messages:
 ```python
-# chain of thoughts
-from pydantic import Field
-
-class Reason(BaseModel):
-  reason: str
-  confidence_score: float
-
-class Thought(BaseModel):
-  thought: str
-
-class Analysis(BaseModel):
-  thought: list[Thought] = Field(
-    default_factory=list, 
-    description="concise Chain of thoughts from you, 3 step, each in 8 words"
-  )
-  analysis: str = Field(
-    ...,
-    description="Final analysis of the dragon's psyche in 20 words",
-  )
-  reason: list[Reason] = Field(
-    default_factory=list,
-    description="Concise Reasoning behind the analysis, 3 support, each in 8 words"
-  )
-
-context1 = "I am a dragon, I think therefore I am, I suffer from shiny objects syndrome"
-context2 = "I like food and poetry, I use uv sometimes, it's cool but I am not familiar with pip"
-
-async def analyze(context) -> Analysis:
-  psychologist = Branch(
-    system="you are a renowned dragon psychologist",
-    imodel=gpt4o,
-  )
-  return await psychologist.communicate(
-    instruction="analyze the dragon's psyche using chain of thoughts",
-    guidance="think step by step, reason with logic",
-    context=context,
-    response_format=Analysis,
-  )
-
+df = branch.to_df()
+print(df.tail())
 ```
+- Action logs show each tool call, arguments, and outcomes.
+- Verbose ReAct provides chain-of-thought analysis (helpful for debugging multi-step flows).
 
-```python
-result1 = await analyze(context1)
-
-print("\nThoughts:")
-for i in result1.thought:
-    print(i.thought)
-
-print("\nAnalysis:")    
-print(result1.analysis)
-
-print("\nReasoning:")
-for i in result1.reason:
-    print(i.reason)
-```
-
-```
-
-Thoughts:
-Dragons are attracted to shiny objects naturally.
-This suggests a strong affinity for hoarding.
-Reflects the dragon's inherent desire for possession.
-
-Analysis:
-The dragon demonstrates a compulsive hoarding behavior linked to attraction for shiny objects.
-
-Reasoning:
-Shiny objects trigger instinctual hoarding behavior.
-Possession indicates a symbol of power and security.
-Hoarding is reinforced by evolutionary survival mechanisms.
-```
+### Example: Multi-Model Orchestration
 
 ```python
-result2 = await analyze(context2)
+from lionagi import Branch, iModel
 
-print("\nThoughts:")
-for i in result2.thought:
-    print(i.thought)
-
-print("\nAnalysis:")    
-print(result2.analysis)
+gpt4o = iModel(provider="openai", model="gpt-4o")
+sonnet = iModel(
+  provider="anthropic",
+  model="claude-3-5-sonnet-20241022",
+  max_tokens=1000,                    # max_tokens is required for anthropic models
+)
 
-print("\nReasoning:")
-for i in result2.reason:
-    print(i.reason)
+branch = Branch(chat_model=gpt4o)
+# Switch mid-flow
+analysis = await branch.communicate("Analyze these stats", imodel=sonnet)
 ```
 
-```
-Thoughts:
-Dragon enjoys both food and poetry regularly.
-Dragon uses uv light with frequent interest.
-Dragon is unfamiliar and not comfortable with pip.
-
-Analysis:
-The dragon is curious and exploratory, yet selectively cautious about unfamiliar methodologies.
-
-Reasoning:
-Preference for food and poetry suggests curiosity.
-Frequent uv light use indicates exploratory nature.
-Discomfort with pip usage shows selective caution.
-```
+Seamlessly route to different models in the same workflow.
 
+## Community & Contributing
 
+We welcome issues, ideas, and pull requests:
+- Discord: Join to chat or get help
+- Issues / PRs: GitHub
 
-## 🌟 Example Workflow
-
-Below is an example of what you can build with LION. Note that these are sample implementations - LION provides the building blocks, you create the workflows that fit your needs.
-
-```mermaid
-sequenceDiagram
-    autonumber
-    participant Client
-    participant Orchestrator
-    participant ResearchAgent
-    participant AnalysisAgent
-    participant ValidationAgent
-    participant Tools
-
-    Client->>+Orchestrator: Submit Complex Task
-    Note over Orchestrator: Task Analysis & Planning
-
-    %% Research Phase
-    Orchestrator->>+ResearchAgent: Delegate Research
-    activate ResearchAgent
-    ResearchAgent->>Tools: Access Data Sources
-    Tools-->>ResearchAgent: Raw Data
-    ResearchAgent-->>-Orchestrator: Research Results
-    deactivate ResearchAgent
-
-    %% Analysis Phase
-    Orchestrator->>+AnalysisAgent: Process Data
-    activate AnalysisAgent
-    AnalysisAgent->>Tools: Apply Models
-    Tools-->>AnalysisAgent: Analysis Results
-    AnalysisAgent-->>-Orchestrator: Processed Insights
-    deactivate AnalysisAgent
-
-    %% Validation Phase
-    Orchestrator->>+ValidationAgent: Verify Results
-    activate ValidationAgent
-    ValidationAgent->>Tools: Apply Safety Checks
-    Tools-->>ValidationAgent: Validation Status
-    ValidationAgent-->>-Orchestrator: Verified Results
-    deactivate ValidationAgent
-
-    Orchestrator-->>-Client: Return Validated Output
+### Citation
 ```
-
-
-## 🤝 Contributing
-
-Join our [Discord community](https://discord.gg/aqSJ2v46vu) to:
-- Share ideas
-- Report issues
-- Contribute code
-- Learn from others
-
-## 📚 Citation
-
-```bibtex
 @software{Li_LionAGI_2023,
   author = {Haiyang Li},
   month = {12},
@@ -547,3 +371,6 @@ Join our [Discord community](https://discord.gg/aqSJ2v46vu) to:
   url = {https://github.com/lion-agi/lionagi},
 }
 ```
+
+**🦁 LionAGI**
+> Because real AI orchestration demands more than a single prompt. Try it out and discover the next evolution in structured, multi-model, safe AI.

lionagi-0.8.7/README.md

@@ -0,0 +1,145 @@
+![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
+![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+
+[Documentation](https://lion-agi.github.io/lionagi/) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
+
+# LION - Language InterOperable Network
+
+## An Intelligence Operating System
+
+LionAGI is a robust framework for orchestrating multi-step AI operations with precise control. Bring together multiple models, advanced ReAct reasoning, tool integrations, and custom validations in a single coherent pipeline.
+
+## Why LionAGI?
+
+- **Structured**: LLM interactions are validated and typed (via Pydantic).
+- **Expandable**: Integrate multiple providers (OpenAI, Anthropic, Perplexity, custom) with minimal friction.
+- **Controlled**: Built-in safety checks, concurrency strategies, and advanced multi-step flows—like ReAct with verbose outputs.
+- **Transparent**: Real-time logging, message introspection, and easy debugging of tool usage.
+
+
+## Installation
+
+```
+pip install lionagi
+```
+
+Dependencies:
+	•	litellm
+	•	jinja2
+	•	pandas
+	•	pillow
+	•	python-dotenv
+
+## Quick Start
+```python
+from lionagi import Branch, iModel
+
+# Pick a model
+gpt4o = iModel(provider="openai", model="gpt-4o")
+
+# Create a Branch (conversation context)
+hunter = Branch(
+  system="you are a hilarious dragon hunter who responds in 10 words rhymes.",
+  chat_model=gpt4o,
+)
+
+# Communicate asynchronously
+response = await hunter.communicate("I am a dragon")
+print(response)
+```
+
+```
+You claim to be a dragon, oh what a braggin'!
+```
+### Structured Responses
+
+Use Pydantic to keep outputs structured:
+
+```python
+from pydantic import BaseModel
+
+class Joke(BaseModel):
+    joke: str
+
+res = await hunter.communicate(
+    "Tell me a short dragon joke",
+    response_format=Joke
+)
+print(type(response))
+print(response.joke)
+```
+```
+<class '__main__.Joke'>
+With fiery claws, dragons hide their laughter flaws!
+```
+
+### ReAct and Tools
+
+LionAGI supports advanced multi-step reasoning with ReAct. Tools let the LLM invoke external actions:
+
+```python
+from lionagi.tools.types import ReaderTool
+
+branch = Branch(chat_model=gpt4o, tools=ReaderTool)
+result = await branch.ReAct(
+    instruct={
+      "instruction": "Summarize my PDF and compare with relevant papers.",
+      "context": {"paper_file_path": "/path/to/paper.pdf"},
+    },
+    extension_allowed=True,     # allow multi-round expansions
+    max_extensions=5,
+    verbose=True,      # see step-by-step chain-of-thought
+)
+print(result)
+```
+
+The LLM can now open the PDF, read in slices, fetch references, and produce a final structured summary.
+
+### Observability & Debugging
+- Inspect messages:
+```python
+df = branch.to_df()
+print(df.tail())
+```
+- Action logs show each tool call, arguments, and outcomes.
+- Verbose ReAct provides chain-of-thought analysis (helpful for debugging multi-step flows).
+
+### Example: Multi-Model Orchestration
+
+```python
+from lionagi import Branch, iModel
+
+gpt4o = iModel(provider="openai", model="gpt-4o")
+sonnet = iModel(
+  provider="anthropic",
+  model="claude-3-5-sonnet-20241022",
+  max_tokens=1000,                    # max_tokens is required for anthropic models
+)
+
+branch = Branch(chat_model=gpt4o)
+# Switch mid-flow
+analysis = await branch.communicate("Analyze these stats", imodel=sonnet)
+```
+
+Seamlessly route to different models in the same workflow.
+
+## Community & Contributing
+
+We welcome issues, ideas, and pull requests:
+- Discord: Join to chat or get help
+- Issues / PRs: GitHub
+
+### Citation
+```
+@software{Li_LionAGI_2023,
+  author = {Haiyang Li},
+  month = {12},
+  year = {2023},
+  title = {LionAGI: Towards Automated General Intelligence},
+  url = {https://github.com/lion-agi/lionagi},
+}
+```
+
+**🦁 LionAGI**
+> Because real AI orchestration demands more than a single prompt. Try it out and discover the next evolution in structured, multi-model, safe AI.

{lionagi-0.8.5 → lionagi-0.8.7}/lionagi/__init__.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import logging
+
 from pydantic import BaseModel, Field
 
 from . import _types as types
@@ -13,6 +15,9 @@ from .version import __version__
 
 LiteiModel = iModel
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
 __all__ = (
     "Session",
     "Branch",
@@ -24,4 +29,5 @@ __all__ = (
     "__version__",
     "BaseModel",
     "Field",
+    "logger",
 )

{lionagi-0.8.5 → lionagi-0.8.7}/lionagi/operations/ReAct/ReAct.py

@@ -28,11 +28,12 @@ async def ReAct(
     tools: Any = None,
     tool_schemas: Any = None,
     response_format: type[BaseModel] | BaseModel = None,
-    extension_allowed: bool = False,
-    max_extensions: int | None = None,
+    extension_allowed: bool = True,
+    max_extensions: int | None = 3,
     response_kwargs: dict | None = None,
     return_analysis: bool = False,
     analysis_model: iModel | None = None,
+    verbose_analysis: bool = False,
     **kwargs,
 ):
     # If no tools or tool schemas are provided, default to "all tools"
@@ -53,6 +54,8 @@ async def ReAct(
             sample_writing=interpret_sample,
             **(interpret_kwargs or {}),
         )
+        if verbose_analysis:
+            print(f"Interpreted instruction: {instruction_str}")
 
     # Convert Instruct to dict if necessary
     instruct_dict = (
@@ -60,10 +63,13 @@ async def ReAct(
         if isinstance(instruct, Instruct)
         else dict(instruct)
     )
-    # Overwrite the "instruction" field with the interpreted string (if any)
-    instruct_dict["instruction"] = instruction_str or instruct_dict.get(
-        "instruction"
-    )
+
+    # Overwrite "instruction" with the interpreted prompt (if any) plus a note about expansions
+    max_ext_info = f"\nIf needed, you can do up to {max_extensions or 0 if extension_allowed else 0} expansions."
+    instruct_dict["instruction"] = (
+        instruction_str
+        or (instruct_dict.get("instruction") or "")  # in case it's missing
+    ) + max_ext_info
 
     # Prepare a copy of user-provided kwargs for the first operate call
     kwargs_for_operate = copy(kwargs)
@@ -81,13 +87,23 @@ async def ReAct(
     )
     analyses = [analysis]
 
+    # If verbose, show round #1 analysis
+    if verbose_analysis:
+        print(
+            f"ReAct Round #1 Analysis:\n {analysis.model_dump_json(indent=2)}",
+        )
+
     # Validate and clamp max_extensions if needed
-    if max_extensions and max_extensions > 5:
-        logging.warning("max_extensions should not exceed 5; defaulting to 5.")
-        max_extensions = 5
+    if max_extensions and max_extensions > 100:
+        logging.warning(
+            "max_extensions should not exceed 100; defaulting to 100."
+        )
+        max_extensions = 100
 
     # Step 2: Possibly loop through expansions if extension_needed
     extensions = max_extensions
+    round_count = 1
+
     while (
         extension_allowed
         and analysis.extension_needed
@@ -103,16 +119,28 @@ async def ReAct(
                 extensions=extensions
             )
 
+        operate_kwargs = copy(kwargs)
+        operate_kwargs["actions"] = True
+        operate_kwargs["reason"] = True
+        operate_kwargs["response_format"] = ReActAnalysis
+        operate_kwargs["action_strategy"] = analysis.action_strategy
+        if analysis.action_batch_size:
+            operate_kwargs["action_batch_size"] = analysis.action_batch_size
+
         analysis = await branch.operate(
             instruction=new_instruction,
-            response_format=ReActAnalysis,
             tools=tools,
             tool_schemas=tool_schemas,
-            reason=True,
-            actions=True,
+            **operate_kwargs,
         )
         analyses.append(analysis)
+        round_count += 1
 
+        # If verbose, show round analysis
+        if verbose_analysis:
+            print(
+                f"ReAct Round #{round_count} Analysis:\n {analysis.model_dump_json(indent=2)}",
+            )
         if extensions:
             extensions -= 1