lionagi 0.15.9__tar.gz → 0.15.13__tar.gz

lionagi-0.15.13/.github/workflows/docs-deploy.yml

@@ -0,0 +1,36 @@
+name: Deploy Documentation
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+          cache: "pip"
+
+      - name: Install dependencies
+        run: |
+          pip install uv
+          uv venv
+          source .venv/bin/activate
+          echo "VIRTUAL_ENV=$GITHUB_WORKSPACE/.venv" >> $GITHUB_ENV
+          echo "$GITHUB_WORKSPACE/.venv/bin" >> $GITHUB_PATH
+          uv sync
+
+      - name: Deploy documentation
+        run: uv run mkdocs gh-deploy --force

{lionagi-0.15.9 → lionagi-0.15.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.15.9
+Version: 0.15.13
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -225,10 +225,10 @@ Requires-Dist: anyio>=4.7.0
 Requires-Dist: backoff>=2.0.0
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: json-repair>=0.40.0
-Requires-Dist: pillow>=11.0.0
+Requires-Dist: pillow>=10.0.0
 Requires-Dist: psutil>=6.0.0
 Requires-Dist: pydantic-settings>=2.8.0
-Requires-Dist: pydapter[pandas]>=1.0.0
+Requires-Dist: pydapter[pandas]>=1.0.4
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.9.0
 Requires-Dist: toml>=0.8.0
@@ -274,13 +274,13 @@ Description-Content-Type: text/markdown
 ![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/) |
+[Documentation](https://khive-ai.github.io/lionagi/) |
 [Discord](https://discord.gg/JDj9ENhUE8) |
 [PyPI](https://pypi.org/project/lionagi/)
 
 # LION - Language InterOperable Network
 
-## An Agentic Intelligence SDK
+## An AGentic Intelligence SDK
 
 LionAGI is a robust framework for orchestrating multi-step AI operations with
 precise control. Bring together multiple models, advanced ReAct reasoning, tool
@@ -288,13 +288,13 @@ integrations, and custom validations in a single coherent pipeline.
 
 ## Why LionAGI?
 
-- **Structured**: LLM interactions are validated and typed (via Pydantic).
+- **Structured**: Validate and type all LLM interactions with 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.
+- **Controlled**: Use built-in safety checks, concurrency strategies, and advanced
+  multi-step flows like ReAct.
+- **Transparent**: Debug easily with real-time logging, message introspection, and
+  tool usage tracking.
 
 ## Installation
 
@@ -310,12 +310,12 @@ pip install lionagi # or install directly
 from lionagi import Branch, iModel
 
 # Pick a model
-gpt41 = iModel(provider="openai", model="gpt-4.1-mini")
+gpt4o = iModel(provider="openai", model="gpt-4o-mini")
 
 # Create a Branch (conversation context)
 hunter = Branch(
   system="you are a hilarious dragon hunter who responds in 10 words rhymes.",
-  chat_model=gpt41,
+  chat_model=gpt4o,
 )
 
 # Communicate asynchronously
@@ -341,8 +341,8 @@ res = await hunter.communicate(
     "Tell me a short dragon joke",
     response_format=Joke
 )
-print(type(response))
-print(response.joke)
+print(type(res))
+print(res.joke)
 ```
 
 ```
@@ -362,7 +362,10 @@ pip install "lionagi[reader]"
 ```python
 from lionagi.tools.types import ReaderTool
 
-branch = Branch(chat_model=gpt4o, tools=ReaderTool)
+# Define model first
+gpt4o = iModel(provider="openai", model="gpt-4o-mini")
+
+branch = Branch(chat_model=gpt4o, tools=[ReaderTool])
 result = await branch.ReAct(
     instruct={
       "instruction": "Summarize my PDF and compare with relevant papers.",
@@ -396,13 +399,15 @@ print(df.tail())
 ```python
 from lionagi import Branch, iModel
 
+# Define models for multi-model orchestration
+gpt4o = iModel(provider="openai", model="gpt-4o-mini")
 sonnet = iModel(
   provider="anthropic",
   model="claude-3-5-sonnet-20241022",
   max_tokens=1000,                    # max_tokens is required for anthropic models
 )
 
-branch = Branch(chat_model=gpt41)
+branch = Branch(chat_model=gpt4o)
 analysis = await branch.communicate("Analyze these stats", chat_model=sonnet) # Switch mid-flow
 ```
 

{lionagi-0.15.9 → lionagi-0.15.13}/README.md

@@ -2,13 +2,13 @@
 ![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/) |
+[Documentation](https://khive-ai.github.io/lionagi/) |
 [Discord](https://discord.gg/JDj9ENhUE8) |
 [PyPI](https://pypi.org/project/lionagi/)
 
 # LION - Language InterOperable Network
 
-## An Agentic Intelligence SDK
+## An AGentic Intelligence SDK
 
 LionAGI is a robust framework for orchestrating multi-step AI operations with
 precise control. Bring together multiple models, advanced ReAct reasoning, tool
@@ -16,13 +16,13 @@ integrations, and custom validations in a single coherent pipeline.
 
 ## Why LionAGI?
 
-- **Structured**: LLM interactions are validated and typed (via Pydantic).
+- **Structured**: Validate and type all LLM interactions with 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.
+- **Controlled**: Use built-in safety checks, concurrency strategies, and advanced
+  multi-step flows like ReAct.
+- **Transparent**: Debug easily with real-time logging, message introspection, and
+  tool usage tracking.
 
 ## Installation
 
@@ -38,12 +38,12 @@ pip install lionagi # or install directly
 from lionagi import Branch, iModel
 
 # Pick a model
-gpt41 = iModel(provider="openai", model="gpt-4.1-mini")
+gpt4o = iModel(provider="openai", model="gpt-4o-mini")
 
 # Create a Branch (conversation context)
 hunter = Branch(
   system="you are a hilarious dragon hunter who responds in 10 words rhymes.",
-  chat_model=gpt41,
+  chat_model=gpt4o,
 )
 
 # Communicate asynchronously
@@ -69,8 +69,8 @@ res = await hunter.communicate(
     "Tell me a short dragon joke",
     response_format=Joke
 )
-print(type(response))
-print(response.joke)
+print(type(res))
+print(res.joke)
 ```
 
 ```
@@ -90,7 +90,10 @@ pip install "lionagi[reader]"
 ```python
 from lionagi.tools.types import ReaderTool
 
-branch = Branch(chat_model=gpt4o, tools=ReaderTool)
+# Define model first
+gpt4o = iModel(provider="openai", model="gpt-4o-mini")
+
+branch = Branch(chat_model=gpt4o, tools=[ReaderTool])
 result = await branch.ReAct(
     instruct={
       "instruction": "Summarize my PDF and compare with relevant papers.",
@@ -124,13 +127,15 @@ print(df.tail())
 ```python
 from lionagi import Branch, iModel
 
+# Define models for multi-model orchestration
+gpt4o = iModel(provider="openai", model="gpt-4o-mini")
 sonnet = iModel(
   provider="anthropic",
   model="claude-3-5-sonnet-20241022",
   max_tokens=1000,                    # max_tokens is required for anthropic models
 )
 
-branch = Branch(chat_model=gpt41)
+branch = Branch(chat_model=gpt4o)
 analysis = await branch.communicate("Analyze these stats", chat_model=sonnet) # Switch mid-flow
 ```
 

lionagi-0.15.13/docs/DOCUMENTATION_STANDARDS.md

@@ -0,0 +1,273 @@
+# LionAGI Documentation Standards
+
+_Practical guidelines for writing docs that actually help._
+
+## Core Principle
+
+**Show, don't tell.** Every page should have working code that solves a real
+problem.
+
+## Page Types & Templates
+
+### 1. Pattern Pages (`/patterns/`)
+
+````markdown
+# [Pattern Name]
+
+When you need to [problem this solves].
+
+## The Pattern
+
+```python
+# Complete working example
+from lionagi import Session, Branch, Builder
+
+async def pattern_name():
+    # Implementation
+    pass
+
+# Usage
+result = await pattern_name()
+```
+````
+
+## When It Works
+
+- Scenario 1: [specific use case]
+- Scenario 2: [another use case]
+
+## Success Rate
+
+~95% based on [context]
+
+````
+### 2. Cookbook Pages (`/cookbook/`)
+
+```markdown
+# [Solution Name]
+
+[One sentence: what this builds]
+
+## Problem
+
+[2-3 sentences on the specific challenge]
+
+## Solution
+
+```python
+# Full implementation
+# Can be 50-200 lines
+# Must be copy-paste ready
+````
+
+## Results
+
+```
+[Actual output from running the code]
+```
+
+## Customization
+
+- To adapt for X: [change this]
+- To scale up: [modify that]
+
+````
+### 3. Concept Pages (`/core-concepts/`)
+
+```markdown
+# [Concept Name]
+
+[One sentence definition]
+
+## Quick Example
+
+```python
+# Minimal example showing the concept
+````
+
+## Key Points
+
+- Point 1: [essential info]
+- Point 2: [essential info]
+- Point 3: [essential info]
+
+## Common Usage
+
+```python
+# Realistic example
+```
+
+````
+### 4. Quickstart Pages
+
+```markdown
+# [Getting Started with X]
+
+## Install
+
+```bash
+uv add lionagi
+````
+
+## First Example
+
+```python
+# Simplest possible working example
+```
+
+## Next Steps
+
+- Try [pattern]
+- Read about [concept]
+- See [cookbook example]
+
+````
+## Code Standards
+
+### Every Code Block Must:
+
+1. **Run without modification** - Include all imports
+2. **Show realistic usage** - Not just toy examples
+3. **Handle errors gracefully** - At least try/except where it matters
+
+```python
+# GOOD: Complete and runnable
+from lionagi import Branch, iModel
+import asyncio
+
+async def example():
+    branch = Branch(chat_model=iModel(provider="openai", model="gpt-4"))
+    try:
+        result = await branch.chat("Analyze this")
+        return result
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+# Run it
+# result = asyncio.run(example())
+````
+
+```python
+# BAD: Fragment without context
+branch.chat("Analyze this")  # What's branch? How to run?
+```
+
+## Writing Style
+
+### Keep It Simple
+
+- **Short sentences** (max 20 words)
+- **Active voice** ("Use X to..." not "X can be used to...")
+- **Direct instructions** ("Do this" not "You might want to consider")
+- **Skip the fluff** (No "In this section we will explore...")
+
+### Show Success Metrics
+
+When claiming something works, show evidence:
+
+- "95% success rate" not "usually works"
+- "2.3 second average" not "fast"
+- "Handles 1000 req/sec" not "scalable"
+
+## For AI Agents
+
+### Pattern Recognition Format
+
+Help AI agents understand when to use patterns:
+
+```markdown
+## When to Use
+
+IF task requires parallel analysis: USE fan-out-in pattern ELIF task needs
+step-by-step building: USE sequential-analysis pattern ELSE: USE single-branch
+ReAct
+```
+
+### Executable Templates
+
+Provide parameterized code AI can modify:
+
+```python
+async def orchestrate(roles: list[str], task: str):
+    """Template AI agents can adapt."""
+    branches = [Branch(system=f"You are a {role}") for role in roles]
+    results = await asyncio.gather(*[b.chat(task) for b in branches])
+    return synthesize(results)
+```
+
+## Documentation Workflow
+
+### Adding New Docs
+
+1. **Check if needed** - Does this solve a new problem?
+2. **Pick the right type** - Pattern, cookbook, concept, or quickstart?
+3. **Use the template** - Don't reinvent the structure
+4. **Test the code** - Every example must run
+5. **Get it merged** - Perfect is the enemy of done
+
+### Updating Docs
+
+- **Fix errors immediately** - Don't wait
+- **Update metrics quarterly** - Keep data fresh
+- **Add examples from issues** - Real problems, real solutions
+
+## Quality Checklist
+
+Before merging any doc:
+
+- [ ] Code runs without errors
+- [ ] Solves a real problem
+- [ ] Uses appropriate template
+- [ ] Includes actual output/metrics
+- [ ] Links to related content
+
+## What NOT to Document
+
+- **Obvious things** - We have good docstrings
+- **Every parameter** - API reference handles that
+- **Theory without practice** - This isn't an academic paper
+- **Features not in main** - Document what's shipped
+
+## Examples of Good Docs
+
+### Good Pattern Doc
+
+- Clear problem statement
+- Complete working code
+- Success metrics
+- When to use/not use
+
+### Good Cookbook Entry
+
+- Specific real-world scenario
+- Full implementation
+- Actual results
+- How to customize
+
+### Good Concept Page
+
+- Simple definition
+- Minimal example
+- Key points only
+- Practical usage
+
+## Maintenance
+
+### Quarterly Review
+
+- Update success metrics
+- Fix broken examples
+- Remove outdated patterns
+- Add new proven patterns
+
+### Continuous
+
+- Fix errors when found
+- Add clarifications from support questions
+- Update for API changes
+
+---
+
+**Remember**: If you wouldn't copy-paste it into your own project, don't put it
+in the docs.

lionagi-0.15.13/docs/advanced/custom-operations.md

@@ -0,0 +1,120 @@
+# Custom Operations
+
+Creating specialized operations for LionAGI workflows.
+
+## Core Concept
+
+Operations are building blocks that branches execute. LionAGI provides built-in
+operations like `chat`, `communicate`, `operate`, and `ReAct`, but you can
+create custom ones for specialized tasks.
+
+## Built-in Operations
+
+- **chat**: Basic conversation
+- **communicate**: Stateful conversation
+- **operate**: Structured output with Pydantic
+- **ReAct**: Reasoning with tools
+
+## Creating Custom Operations
+
+### Function-Based Operations
+
+Define async functions for custom behavior:
+
+```python
+from lionagi import Branch, Builder, Session
+
+async def summarize_with_keywords(branch: Branch, instruction: str, keywords: list = None, **kwargs):
+    """Custom operation that emphasizes specific keywords."""
+    keyword_text = f"Focus on: {', '.join(keywords or [])}"
+    enhanced_instruction = f"{instruction}\n\n{keyword_text}"
+    
+    return await branch.chat(enhanced_instruction, **kwargs)
+
+# Usage in workflow
+session = Session()
+builder = Builder("custom_workflow")
+
+node = builder.add_operation(
+    operation=summarize_with_keywords,
+    instruction="Summarize this research paper",
+    keywords=["machine learning", "performance"]
+)
+
+result = await session.flow(builder.get_graph())
+```
+
+### Class-Based Operations
+
+For stateful operations, use classes:
+
+```python
+class DataAnalysisOperation:
+    def __init__(self, analysis_type: str = "descriptive"):
+        self.analysis_type = analysis_type
+    
+    async def __call__(self, branch: Branch, data_context: str, **kwargs):
+        instruction = f"""
+        Perform {self.analysis_type} analysis on: {data_context}
+        
+        Provide:
+        1. Key findings
+        2. Statistical insights  
+        3. Recommendations
+        """
+        
+        return await branch.chat(instruction, **kwargs)
+
+# Usage
+analyzer = DataAnalysisOperation("predictive")
+
+builder.add_operation(
+    operation=analyzer,
+    data_context="Sales data Q1-Q3 2024"
+)
+```
+
+## Integration Patterns
+
+### Sequential Dependencies
+
+```python
+# Operations run in order
+data_load = builder.add_operation(
+    operation="communicate",
+    instruction="Load and validate dataset"
+)
+
+analyze = builder.add_operation(
+    operation=analyzer,
+    depends_on=[data_load],
+    data_context="Use loaded data"
+)
+```
+
+### Parallel with Aggregation
+
+```python
+# Multiple analyses run in parallel
+analysis_nodes = []
+for analysis_type in ["descriptive", "predictive"]:
+    node = builder.add_operation(
+        operation=DataAnalysisOperation(analysis_type),
+        data_context="Sales data"
+    )
+    analysis_nodes.append(node)
+
+# Combine results
+summary = builder.add_aggregation(
+    operation="communicate",
+    source_node_ids=analysis_nodes,
+    instruction="Combine analyses into executive summary"
+)
+```
+
+## Best Practices
+
+- **Keep operations focused** on single responsibilities
+- **Use existing LionAGI operations** (`chat`, `communicate`) when possible
+- **Handle errors gracefully** with try/catch in custom logic
+- **Test operations independently** before integrating into workflows