lionagi 0.3.7__tar.gz → 0.4.0__tar.gz

lionagi-0.4.0/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.1
+Name: lionagi
+Version: 0.4.0
+Summary: Towards automated general intelligence.
+Author: HaiyangLi
+Author-email: quantocean.li@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiocache (>=0.12.0,<0.13.0)
+Requires-Dist: ipython (>=8.0.0,<9.0.0)
+Requires-Dist: lion-core (==0.5.6)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
+![Dependencies](https://img.shields.io/badge/dependencies-4-brightgreen)
+![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+
+[Documentation](https://ocean-lion.com/Welcome) | [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
+
+> Harness the power of next-generation AI while maintaining complete control and reliability.
+
+## Why LION?
+
+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
+
+## Quick Start
+
+```python
+from lionagi import Branch, iModel
+
+# Initialize model
+gpt4o = iModel(provider="openai", model="gpt-4o")
+
+# Create a branch with personality
+comedian = Branch(
+    system="you are a sarcastic dragon hunter",
+    imodel=gpt4o
+)
+
+# Chat asynchronously
+response = await comedian.chat(
+    "tell me a joke on knight vs dragon"
+)
+```
+
+## Installation
+
+LION maintains minimal dependencies for maximum reliability:
+
+```bash
+pip install lionagi
+```
+
+Dependencies:
+- aiocache
+- lion-core
+- python-dotenv
+- IPython
+
+## 🌟 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
+```
+
+## 🏗️ System Architecture
+
+Here's how you can structure your LION-powered system. Each component can be customized to your specific needs.
+
+```mermaid
+graph TB
+    subgraph Client Layer
+        CL[Client Application]
+    end
+
+    subgraph Orchestration Layer
+        ORC[Orchestrator]
+        SEC[Security Controls]
+        MON[Monitoring]
+    end
+
+    subgraph Agent Layer
+        subgraph Specialized Agents
+            RA[Research Agent]
+            AA[Analysis Agent]
+            VA[Validation Agent]
+        end
+
+        subgraph Agent Controls
+            AC[Access Control]
+            AM[Action Monitor]
+            VE[Verification]
+        end
+    end
+
+    subgraph Resource Layer
+        subgraph Tool Management
+            TM[Tool Registry]
+            TP[Tool Policies]
+        end
+
+        subgraph Data Sources
+            DS[Data Access]
+            DV[Data Validation]
+        end
+    end
+
+    %% Connections
+    CL --> ORC
+    ORC --> RA & AA & VA
+    RA & AA & VA --> AC
+    AC --> TM
+    TM --> DS
+
+    %% Control Flow
+    ORC --> SEC
+    SEC --> MON
+    MON --> AM
+    AM --> VE
+    VE --> TP
+    TP --> DV
+
+    classDef primary fill:#1e40af,stroke:#1e3a8a,color:#fff
+    classDef secondary fill:#3b82f6,stroke:#2563eb,color:#fff
+    classDef control fill:#7c3aed,stroke:#6d28d9,color:#fff
+```
+
+## 🛠️ Building Blocks
+
+LION provides the essential components you need to build reliable AI workflows:
+
+- **Branch**: Core conversation unit with built-in safety mechanisms
+- **iModel**: Standardized interface to AI models
+- **Tools**: Framework for safe tool integration
+- **Exchange**: Reliable message passing between components
+
+Each component is designed to be:
+- Fully customizable to your needs
+- Safe by default
+- Easy to integrate
+- Highly reliable
+
+## 🎯 Key Use Cases
+
+- **Enterprise Operations**
+  - Complex workflow automation
+  - Data analysis and processing
+  - Decision support systems
+
+- **AI Integration**
+  - Controlled model deployment
+  - Safe tool usage
+  - Reliable agent operations
+
+- **Development**
+  - Rapid prototyping
+  - System integration
+  - Workflow optimization
+
+## 🔒 Built for Reliability
+
+LION isn't just another framework - it's your partner in responsible AI adoption. Build enterprise-grade AI systems with:
+
+- Complete control over AI behaviors
+- Comprehensive audit trails
+- Built-in safety mechanisms
+- Minimal dependencies
+- Maximum reliability
+
+## 🤝 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},
+  year = {2023},
+  title = {LionAGI: Intelligent Integration Framework},
+  url = {https://github.com/lion-agi/lionagi},
+}
+```
+

lionagi-0.4.0/README.md

@@ -0,0 +1,223 @@
+![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
+![Dependencies](https://img.shields.io/badge/dependencies-4-brightgreen)
+![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+
+[Documentation](https://ocean-lion.com/Welcome) | [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
+
+> Harness the power of next-generation AI while maintaining complete control and reliability.
+
+## Why LION?
+
+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
+
+## Quick Start
+
+```python
+from lionagi import Branch, iModel
+
+# Initialize model
+gpt4o = iModel(provider="openai", model="gpt-4o")
+
+# Create a branch with personality
+comedian = Branch(
+    system="you are a sarcastic dragon hunter",
+    imodel=gpt4o
+)
+
+# Chat asynchronously
+response = await comedian.chat(
+    "tell me a joke on knight vs dragon"
+)
+```
+
+## Installation
+
+LION maintains minimal dependencies for maximum reliability:
+
+```bash
+pip install lionagi
+```
+
+Dependencies:
+- aiocache
+- lion-core
+- python-dotenv
+- IPython
+
+## 🌟 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
+```
+
+## 🏗️ System Architecture
+
+Here's how you can structure your LION-powered system. Each component can be customized to your specific needs.
+
+```mermaid
+graph TB
+    subgraph Client Layer
+        CL[Client Application]
+    end
+
+    subgraph Orchestration Layer
+        ORC[Orchestrator]
+        SEC[Security Controls]
+        MON[Monitoring]
+    end
+
+    subgraph Agent Layer
+        subgraph Specialized Agents
+            RA[Research Agent]
+            AA[Analysis Agent]
+            VA[Validation Agent]
+        end
+
+        subgraph Agent Controls
+            AC[Access Control]
+            AM[Action Monitor]
+            VE[Verification]
+        end
+    end
+
+    subgraph Resource Layer
+        subgraph Tool Management
+            TM[Tool Registry]
+            TP[Tool Policies]
+        end
+
+        subgraph Data Sources
+            DS[Data Access]
+            DV[Data Validation]
+        end
+    end
+
+    %% Connections
+    CL --> ORC
+    ORC --> RA & AA & VA
+    RA & AA & VA --> AC
+    AC --> TM
+    TM --> DS
+
+    %% Control Flow
+    ORC --> SEC
+    SEC --> MON
+    MON --> AM
+    AM --> VE
+    VE --> TP
+    TP --> DV
+
+    classDef primary fill:#1e40af,stroke:#1e3a8a,color:#fff
+    classDef secondary fill:#3b82f6,stroke:#2563eb,color:#fff
+    classDef control fill:#7c3aed,stroke:#6d28d9,color:#fff
+```
+
+## 🛠️ Building Blocks
+
+LION provides the essential components you need to build reliable AI workflows:
+
+- **Branch**: Core conversation unit with built-in safety mechanisms
+- **iModel**: Standardized interface to AI models
+- **Tools**: Framework for safe tool integration
+- **Exchange**: Reliable message passing between components
+
+Each component is designed to be:
+- Fully customizable to your needs
+- Safe by default
+- Easy to integrate
+- Highly reliable
+
+## 🎯 Key Use Cases
+
+- **Enterprise Operations**
+  - Complex workflow automation
+  - Data analysis and processing
+  - Decision support systems
+
+- **AI Integration**
+  - Controlled model deployment
+  - Safe tool usage
+  - Reliable agent operations
+
+- **Development**
+  - Rapid prototyping
+  - System integration
+  - Workflow optimization
+
+## 🔒 Built for Reliability
+
+LION isn't just another framework - it's your partner in responsible AI adoption. Build enterprise-grade AI systems with:
+
+- Complete control over AI behaviors
+- Comprehensive audit trails
+- Built-in safety mechanisms
+- Minimal dependencies
+- Maximum reliability
+
+## 🤝 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},
+  year = {2023},
+  title = {LionAGI: Intelligent Integration Framework},
+  url = {https://github.com/lion-agi/lionagi},
+}
+```

lionagi-0.4.0/lionagi/core/director/operations/select.py

@@ -0,0 +1,3 @@
+from lionagi.operations.select import select
+
+__all__ = ["select"]

{lionagi-0.3.7 → lionagi-0.4.0}/lionagi/core/rule/choice.py

@@ -1,4 +1,4 @@
-from lionfuncs import choose_most_similar
+from lionfuncs import string_similarity
 
 from lionagi.core.rule.base import Rule
 
@@ -45,4 +45,4 @@ class ChoiceRule(Rule):
         Returns:
             str: The most similar value from the set of predefined choices.
         """
-        return choose_most_similar(value, self.keys)
+        return string_similarity(value, self.keys, choose_most_similar=True)

lionagi-0.4.0/lionagi/operations/__init__.py

@@ -0,0 +1,6 @@
+from .brainstorm import brainstorm
+from .rank import rank
+from .score import score
+from .select import select
+
+__all__ = ["brainstorm", "rank", "score", "select"]

lionagi-0.4.0/lionagi/operations/brainstorm.py

@@ -0,0 +1,87 @@
+from typing import Any
+
+from lion_core.operative.step_model import StepModel
+from lion_core.session.branch import Branch
+from lion_service import iModel
+from pydantic import BaseModel, Field
+
+from .config import DEFAULT_CHAT_CONFIG
+
+
+class BrainstormModel(BaseModel):
+
+    topic: str = Field(
+        default_factory=str,
+        description="**Specify the topic or theme for the brainstorming session.**",
+    )
+    ideas: list[StepModel] = Field(
+        default_factory=list,
+        description="**Provide a list of ideas needed to accomplish the objective. Each step should be as described in a `PlanStepModel`.**",
+    )
+
+
+PROMPT = "Please follow prompt and provide {num_steps} different ideas for the next step"
+
+
+async def brainstorm(
+    num_steps: int = 3,
+    instruction=None,
+    guidance=None,
+    context=None,
+    system=None,
+    reason: bool = False,
+    actions: bool = False,
+    tools: Any = None,
+    imodel: iModel = None,
+    branch: Branch = None,
+    sender=None,
+    recipient=None,
+    clear_messages: bool = False,
+    system_sender=None,
+    system_datetime=None,
+    return_branch=False,
+    num_parse_retries: int = 3,
+    retry_imodel: iModel = None,
+    branch_user=None,
+    **kwargs,  # additional operate arguments
+):
+    if branch and branch.imodel:
+        imodel = imodel or branch.imodel
+    else:
+        imodel = imodel or iModel(**DEFAULT_CHAT_CONFIG)
+
+    prompt = PROMPT.format(num_steps=num_steps)
+
+    branch = branch or Branch(imodel=imodel)
+    if branch_user:
+        branch.user = branch_user
+
+    if system:
+        branch.add_message(
+            system=system,
+            system_datetime=system_datetime,
+            sender=system_sender,
+        )
+    _context = [{"operation": prompt}]
+    if context:
+        _context.append(context)
+
+    response = await branch.operate(
+        instruction=instruction,
+        guidance=guidance,
+        context=_context,
+        sender=sender,
+        recipient=recipient,
+        reason=reason,
+        actions=actions,
+        tools=tools,
+        clear_messages=clear_messages,
+        operative_model=BrainstormModel,
+        retry_imodel=retry_imodel,
+        num_parse_retries=num_parse_retries,
+        imodel=imodel,
+        **kwargs,
+    )
+    if return_branch:
+        return response, branch
+    return response

lionagi-0.4.0/lionagi/operations/config.py

@@ -0,0 +1,6 @@
+DEFAULT_CHAT_CONFIG = {
+    "provider": "openai",
+    "task": "chat",
+    "model": "gpt-4o-mini",
+    "api_key": "OPENAI_API_KEY",
+}

lionagi-0.4.0/lionagi/operations/rank.py

@@ -0,0 +1,102 @@
+import asyncio
+from typing import Any
+
+import numpy as np
+from lion_core.session.branch import Branch
+from lion_core.session.session import Session
+from lion_service import iModel
+from lionfuncs import alcall, to_list
+
+from .config import DEFAULT_CHAT_CONFIG
+from .score import score
+
+PROMPT = (
+    "Given all items: \n {choices} \n\n Please follow prompt and give score "
+    "to the item of interest: \n {item} \n\n"
+)
+
+
+async def rank(
+    choices: list[Any],
+    num_scorers: int = 5,
+    instruction=None,
+    guidance=None,
+    context=None,
+    system=None,
+    reason: bool = False,
+    actions: bool = False,
+    tools: Any = None,
+    imodel: iModel = None,
+    branch: Branch = None,  # branch won't be used for the vote, it is for configuration
+    clear_messages: bool = False,
+    system_sender=None,
+    system_datetime=None,
+    num_parse_retries: int = 0,
+    retry_imodel: iModel = None,
+    return_session: bool = False,
+    **kwargs,  # additional kwargs for score function
+) -> dict:
+
+    if branch and branch.imodel:
+        imodel = imodel or branch.imodel
+    else:
+        imodel = imodel or iModel(**DEFAULT_CHAT_CONFIG)
+
+    branch = branch or Branch(imodel=imodel)
+    session = Session(default_branch=branch)
+
+    async def _score(item):
+        async with session.branches.async_lock:
+            b_ = session.new_branch(messages=session.default_branch.messages)
+
+        prompt = PROMPT.format(choices=choices, item=item)
+        if instruction:
+            prompt = f"{instruction}\n\n{prompt} \n\n "
+
+        kwargs["branch"] = b_
+        kwargs["score_range"] = kwargs.get("score_range", (1, 10))
+        kwargs["num_scores"] = kwargs.get("num_scores", 1)
+        kwargs["precision"] = kwargs.get("precision", 1)
+
+        response = await score(
+            instruction=prompt,
+            guidance=guidance,
+            context=context,
+            system=system,
+            system_datetime=system_datetime,
+            system_sender=system_sender,
+            sender=session.ln_id,
+            recipient=b_.ln_id,
+            default_score=-1,
+            reason=reason,
+            actions=actions,
+            tools=tools,
+            clear_messages=clear_messages,
+            num_parse_retries=num_parse_retries,
+            retry_imodel=retry_imodel,
+            **kwargs,
+        )
+
+        if response.score == -1:
+            return None
+
+        return response
+
+    async def _group_score(item):
+        tasks = [asyncio.create_task(_score(item)) for _ in range(num_scorers)]
+        responses = await asyncio.gather(*tasks)
+        responses = [i for i in responses if i is not None]
+        scores = to_list(
+            [i.score for i in responses], dropna=True, flatten=True
+        )
+        return {
+            "item": item,
+            "scores": scores,
+            "average": np.mean(scores) if scores else -1,
+        }
+
+    results = await alcall(choices, _group_score)
+    results = sorted(results, key=lambda x: x["average"], reverse=True)
+    if return_session:
+        return results, session
+    return results