praisonaiagents 0.0.99__py3-none-any.whl → 0.0.101__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -619,12 +619,9 @@ Your Goal: {self.goal}
         while retry_count <= self.max_guardrail_retries:
             # Create TaskOutput object
             task_output = TaskOutput(
+                description="Agent response output",
                 raw=current_response,
-                output=current_response,
-                pydantic=None,
-                json_dict=None,
-                name=f"{self.name}_output",
-                description="Agent response output"
+                agent=self.name
             )
             
             # Process guardrail

praisonaiagents/guardrails/__init__.py

@@ -0,0 +1,11 @@
+"""
+Guardrails module for PraisonAI Agents.
+
+This module provides validation and safety mechanisms for task outputs,
+including both function-based and LLM-based guardrails.
+"""
+
+from .guardrail_result import GuardrailResult
+from .llm_guardrail import LLMGuardrail
+
+__all__ = ["GuardrailResult", "LLMGuardrail"]

praisonaiagents/guardrails/guardrail_result.py

@@ -0,0 +1,43 @@
+"""
+Guardrail result classes for PraisonAI Agents.
+
+This module provides the result types for guardrail validation,
+following the same pattern as CrewAI for consistency.
+"""
+
+from typing import Any, Tuple, Union
+from pydantic import BaseModel, Field
+from ..main import TaskOutput
+
+
+class GuardrailResult(BaseModel):
+    """Result of a guardrail validation."""
+    
+    success: bool = Field(description="Whether the guardrail check passed")
+    result: Union[str, TaskOutput, None] = Field(description="The result if modified, or None if unchanged")
+    error: str = Field(default="", description="Error message if validation failed")
+    
+    @classmethod
+    def from_tuple(cls, result: Tuple[bool, Any]) -> "GuardrailResult":
+        """Create a GuardrailResult from a tuple returned by a guardrail function.
+        
+        Args:
+            result: Tuple of (success, result_or_error)
+            
+        Returns:
+            GuardrailResult: The structured result
+        """
+        success, data = result
+        
+        if success:
+            return cls(
+                success=True,
+                result=data,
+                error=""
+            )
+        else:
+            return cls(
+                success=False,
+                result=None,
+                error=str(data) if data else "Guardrail validation failed"
+            )

praisonaiagents/guardrails/llm_guardrail.py

@@ -0,0 +1,88 @@
+"""
+LLM-based guardrail implementation for PraisonAI Agents.
+
+This module provides LLM-powered guardrails that can validate task outputs
+using natural language descriptions, similar to CrewAI's implementation.
+"""
+
+import logging
+from typing import Any, Tuple, Union, Optional
+from pydantic import BaseModel
+from ..main import TaskOutput
+
+
+class LLMGuardrail:
+    """An LLM-powered guardrail that validates task outputs using natural language."""
+    
+    def __init__(self, description: str, llm: Any = None):
+        """Initialize the LLM guardrail.
+        
+        Args:
+            description: Natural language description of what to validate
+            llm: The LLM instance to use for validation
+        """
+        self.description = description
+        self.llm = llm
+        self.logger = logging.getLogger(__name__)
+    
+    def __call__(self, task_output: TaskOutput) -> Tuple[bool, Union[str, TaskOutput]]:
+        """Validate the task output using the LLM.
+        
+        Args:
+            task_output: The task output to validate
+            
+        Returns:
+            Tuple of (success, result) where result is the output or error message
+        """
+        try:
+            if not self.llm:
+                self.logger.warning("No LLM provided for guardrail validation")
+                return True, task_output
+            
+            # Create validation prompt
+            validation_prompt = f"""
+You are a quality assurance validator. Your task is to evaluate the following output against specific criteria.
+
+Validation Criteria: {self.description}
+
+Output to Validate:
+{task_output.raw}
+
+Please evaluate if this output meets the criteria. Respond with:
+1. "PASS" if the output meets all criteria
+2. "FAIL: [specific reason]" if the output does not meet criteria
+
+Your response:"""
+
+            # Get LLM response
+            if hasattr(self.llm, 'chat'):
+                # For Agent's LLM interface
+                response = self.llm.chat(validation_prompt, temperature=0.1)
+            elif hasattr(self.llm, 'get_response'):
+                # For custom LLM instances
+                response = self.llm.get_response(validation_prompt, temperature=0.1)
+            elif callable(self.llm):
+                # For simple callable LLMs
+                response = self.llm(validation_prompt)
+            else:
+                self.logger.error(f"Unsupported LLM type: {type(self.llm)}")
+                return True, task_output
+            
+            # Parse response
+            response = str(response).strip()
+            
+            if response.upper().startswith("PASS"):
+                return True, task_output
+            elif response.upper().startswith("FAIL"):
+                # Extract the reason
+                reason = response[5:].strip(": ")
+                return False, f"Guardrail validation failed: {reason}"
+            else:
+                # Unclear response, log and pass through
+                self.logger.warning(f"Unclear guardrail response: {response}")
+                return True, task_output
+                
+        except Exception as e:
+            self.logger.error(f"Error in LLM guardrail validation: {str(e)}")
+            # On error, pass through the original output
+            return True, task_output

praisonaiagents/memory/__init__.py

@@ -0,0 +1,15 @@
+"""
+Memory module for PraisonAI Agents
+
+This module provides memory management capabilities including:
+- Short-term memory (STM) for ephemeral context
+- Long-term memory (LTM) for persistent knowledge  
+- Entity memory for structured data
+- User memory for preferences/history
+- Quality-based storage decisions
+- Graph memory support via Mem0
+"""
+
+from .memory import Memory
+
+__all__ = ["Memory"] 

praisonaiagents/memory/memory.py

@@ -910,11 +910,14 @@ class Memory:
         """
 
         try:
-            # Use OpenAI client from main.py
-            from ..main import client
+            # Use LiteLLM for consistency with the rest of the codebase
+            import litellm
             
-            response = client.chat.completions.create(
-                model=llm or "gpt-4o",
+            # Convert model name if it's in litellm format
+            model_name = llm or "gpt-4o-mini"
+            
+            response = litellm.completion(
+                model=model_name,
                 messages=[{
                     "role": "user", 
                     "content": custom_prompt or default_prompt

praisonaiagents/task/task.py

@@ -308,7 +308,11 @@ class Task:
                 if self.agent:
                     if getattr(self.agent, '_using_custom_llm', False) and hasattr(self.agent, 'llm_instance'):
                         # For custom LLM instances (like Ollama)
-                        llm_model = self.agent.llm_instance
+                        # Extract the model name from the LLM instance
+                        if hasattr(self.agent.llm_instance, 'model'):
+                            llm_model = self.agent.llm_instance.model
+                        else:
+                            llm_model = "gpt-4o-mini"  # Default fallback
                     elif hasattr(self.agent, 'llm') and self.agent.llm:
                         # For standard model strings
                         llm_model = self.agent.llm

praisonaiagents/tools/README.md

@@ -0,0 +1,155 @@
+# PraisonAI Tools Guide
+
+Welcome to the PraisonAI Tools directory! This guide will help you understand how our tools work and how to create new ones, whether you're a beginner or an experienced programmer.
+
+## What is a Tool?
+
+A tool is a piece of code that helps our AI agents perform specific tasks. Think of tools as special abilities that we give to our agents. For example:
+- An internet search tool lets agents search the web
+- A stock market tool lets agents check stock prices
+- A weather tool lets agents check the weather
+
+## Creating New Tools: The Two Approaches
+
+### 1. Function-Based Approach (Simple Tools)
+
+Best for simple tools that do one specific thing. Like a calculator that just adds numbers.
+
+**When to use:**
+- Tool does one simple task
+- Doesn't need to remember information between uses
+- Doesn't need to share information with other tools
+- Quick, one-time operations
+
+**Example:**
+```python
+def internet_search(query: str):
+    # Search the internet and return results
+    return search_results
+```
+
+**Usage:**
+```python
+from praisonaiagents.tools import internet_search
+
+results = internet_search("AI news")
+```
+
+### 2. Class-Based Approach (Complex Tools)
+
+Best for tools that do multiple related things or need to remember information. Like a smart calculator that remembers your previous calculations and can do many different math operations.
+
+**When to use:**
+- Tool has multiple related functions
+- Needs to remember or share information
+- Needs to manage resources efficiently
+- Has complex setup requirements
+
+**Example:**
+```python
+class StockTools:
+    def get_stock_price(self, symbol):
+        # Get current stock price
+        return price
+        
+    def get_stock_info(self, symbol):
+        # Get detailed stock information
+        return info
+```
+
+**Usage:**
+```python
+from praisonaiagents.tools import get_stock_price, get_stock_info
+
+price = get_stock_price("AAPL")
+info = get_stock_info("AAPL")
+```
+
+## How to Choose Your Approach
+
+Ask yourself these questions:
+
+1. **Is your tool doing one simple thing?**
+   - Yes → Use Function-Based Approach
+   - No → Consider Class-Based Approach
+
+2. **Does your tool need to remember information?**
+   - Yes → Use Class-Based Approach
+   - No → Use Function-Based Approach
+
+3. **Are your tool's operations related to each other?**
+   - Yes → Use Class-Based Approach
+   - No → Use Function-Based Approach
+
+4. **Does your tool need to manage resources efficiently?**
+   - Yes → Use Class-Based Approach
+   - No → Use Function-Based Approach
+
+## Real-World Examples
+
+### Internet Search Tool (Function-Based)
+- Does one thing: searches the internet
+- Doesn't need to remember previous searches
+- Each search is independent
+- Simple input/output operation
+
+### SearxNG Search Tool (Function-Based)
+- Privacy-focused web search using local SearxNG instance
+- Simple search operation with customizable parameters
+- Each search is independent and secure
+- Alternative to traditional search engines for privacy
+
+### Stock Market Tool (Class-Based)
+- Does multiple things: check prices, get company info, get historical data
+- Remembers stock information to avoid repeated downloads
+- Operations are related (all about stocks)
+- Manages connections efficiently
+
+## Getting Started
+
+1. **Choose Your Approach** based on the guidelines above
+
+2. **Create Your Tool File**:
+   - Name it descriptively (e.g., `weather_tools.py`)
+   - Place it in the `praisonaiagents/tools` directory
+
+3. **Write Your Tool**:
+   - Add clear documentation
+   - Include type hints for better understanding
+   - Handle errors gracefully
+
+4. **Test Your Tool**:
+   - Make sure it works as expected
+   - Test error cases
+   - Check performance
+
+## Best Practices
+
+1. **Documentation**:
+   - Explain what your tool does
+   - Provide examples
+   - List any requirements
+
+2. **Error Handling**:
+   - Always handle possible errors
+   - Return helpful error messages
+   - Don't let your tool crash
+
+3. **Performance**:
+   - Keep it efficient
+   - Don't waste resources
+   - Cache when helpful
+
+4. **User-Friendly**:
+   - Make it easy to use
+   - Use clear function/method names
+   - Keep it simple
+
+## Need Help?
+
+- Check existing tools for examples
+- Ask in our community
+- Read the documentation
+- Don't hesitate to ask questions!
+
+Remember: The goal is to make tools that are easy to use and maintain. Choose the approach that makes the most sense for your specific tool's needs.

praisonaiagents/tools/searxng_tools.py

@@ -0,0 +1,94 @@
+"""SearxNG search functionality.
+
+Usage:
+from praisonaiagents.tools import searxng_search
+results = searxng_search("AI news")
+
+or 
+from praisonaiagents.tools import searxng
+results = searxng("AI news")
+"""
+
+from typing import List, Dict, Optional
+import logging
+from importlib import util
+
+def searxng_search(
+    query: str, 
+    max_results: int = 5,
+    searxng_url: Optional[str] = None
+) -> List[Dict]:
+    """Perform an internet search using SearxNG instance.
+    
+    Args:
+        query: Search query string
+        max_results: Maximum number of results to return
+        searxng_url: SearxNG instance URL (defaults to localhost:32768)
+        
+    Returns:
+        List[Dict]: Search results with title, url, and snippet keys
+                   Returns error dict on failure
+    """
+    # Check if requests is available
+    if util.find_spec("requests") is None:
+        error_msg = "SearxNG search requires requests package. Install with: pip install requests"
+        logging.error(error_msg)
+        return [{"error": error_msg}]
+    
+    try:
+        import requests
+        
+        # Default URL for local SearxNG instance
+        url = searxng_url or "http://localhost:32768/search"
+        
+        params = {
+            'q': query, 
+            'format': 'json',
+            'engines': 'google,bing,duckduckgo',  # Multiple engines
+            'safesearch': '1'  # Safe search enabled
+        }
+        
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
+        
+        raw_results = response.json().get('results', [])
+        
+        # Standardize to PraisonAI format
+        results = []
+        for i, result in enumerate(raw_results[:max_results]):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("url", ""),
+                "snippet": result.get("content", "")
+            })
+            
+        return results
+        
+    except requests.exceptions.ConnectionError:
+        error_msg = f"Could not connect to SearxNG at {url}. Ensure SearxNG is running."
+        logging.error(error_msg)
+        return [{"error": error_msg}]
+    except requests.exceptions.Timeout:
+        error_msg = "SearxNG search request timed out"
+        logging.error(error_msg)
+        return [{"error": error_msg}]
+    except requests.exceptions.RequestException as e:
+        error_msg = f"SearxNG search request failed: {e}"
+        logging.error(error_msg)
+        return [{"error": error_msg}]
+    except (ValueError, KeyError) as e:
+        error_msg = f"Error parsing SearxNG response: {e}"
+        logging.error(error_msg)
+        return [{"error": error_msg}]
+
+def searxng(query: str, max_results: int = 5, searxng_url: Optional[str] = None) -> List[Dict]:
+    """Alias for searxng_search function."""
+    return searxng_search(query, max_results, searxng_url)
+
+if __name__ == "__main__":
+    # Example usage
+    results = searxng_search("Python programming")
+    for result in results:
+        print(f"\nTitle: {result.get('title')}")
+        print(f"URL: {result.get('url')}")
+        print(f"Snippet: {result.get('snippet')}")

{praisonaiagents-0.0.99.dist-info → praisonaiagents-0.0.101.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.99
+Version: 0.0.101
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10
@@ -14,6 +14,7 @@ Requires-Dist: fastapi>=0.115.0; extra == "mcp"
 Requires-Dist: uvicorn>=0.34.0; extra == "mcp"
 Provides-Extra: memory
 Requires-Dist: chromadb>=1.0.0; extra == "memory"
+Requires-Dist: litellm>=1.50.0; extra == "memory"
 Provides-Extra: knowledge
 Requires-Dist: mem0ai>=0.1.0; extra == "knowledge"
 Requires-Dist: chromadb>=1.0.0; extra == "knowledge"

{praisonaiagents-0.0.99.dist-info → praisonaiagents-0.0.101.dist-info}/RECORD

@@ -3,11 +3,14 @@ praisonaiagents/approval.py,sha256=UJ4OhfihpFGR5CAaMphqpSvqdZCHi5w2MGw1MByZ1FQ,9
 praisonaiagents/main.py,sha256=_-XE7_Y7ChvtLQMivfNFrrnAhv4wSSDhH9WJMWlkS0w,16315
 praisonaiagents/session.py,sha256=CI-ffCiOfmgB-1zFFik9daKCB5Sm41Q9ZOaq1-oSLW8,9250
 praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
-praisonaiagents/agent/agent.py,sha256=gWTkPOhNHLosZbeZSWXp9sk4H9AN531EgclHmWeZVXk,97881
+praisonaiagents/agent/agent.py,sha256=it38pIYzHQIn2qscIuuvfgWyC9gPLZFj-nN8tDI8x5A,97766
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=C_yDdJB4XUuwKA9DrysAtAj3zSYT0IKtfCT4Pxo0oyI,63309
 praisonaiagents/agents/autoagents.py,sha256=Lc_b9mO2MeefBrsHkHoqFxEr5iRGrYuzDhslyybXwdw,13649
+praisonaiagents/guardrails/__init__.py,sha256=HA8zhp-KRHTxo0194MUwXOUJjPyjOu7E3d7xUIKYVVY,310
+praisonaiagents/guardrails/guardrail_result.py,sha256=2K1WIYRyT_s1H6vBGa-7HEHzXCFIyZXZVY4f0hnQyWc,1352
+praisonaiagents/guardrails/llm_guardrail.py,sha256=MTTqmYDdZX-18QN9T17T5P_6H2qnV8GVgymJufW1WuM,3277
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=OKPar-XGyAp1ndmbOOdCgqFnTCqpOThYVSIZRxZyP58,15683
@@ -16,11 +19,13 @@ praisonaiagents/llm/llm.py,sha256=hoIxHzo9aNygeOiw9RtoPhpuSCVTUrKPe3OPvsT5qLc,98
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
 praisonaiagents/mcp/mcp.py,sha256=_gfp8hrSVT9aPqEDDfU8MiCdg0-3dVQpEQUE6AbrJlo,17243
 praisonaiagents/mcp/mcp_sse.py,sha256=DLh3F_aoVRM1X-7hgIOWOw4FQ1nGmn9YNbQTesykzn4,6792
-praisonaiagents/memory/memory.py,sha256=6tvsLWkpvyNU-t-8d6XpW7vOFUm1pNReW5B7rA8c04M,38612
+praisonaiagents/memory/__init__.py,sha256=aEFdhgtTqDdMhc_JCWM-f4XI9cZIj7Wz5g_MUa-0amg,397
+praisonaiagents/memory/memory.py,sha256=x6CEMYhgzvlJH6SGKHPLRDt6kF0DVFFSUQbgr1OK3JM,38729
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=gxhMXG3s4CzaREyuwE5zxCMx2Wp_b_Wd53tDfkj8Qk8,66567
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=60JE07JPpRowbEO420f4Ol49e_1AK856wSJDi_ricbg,20531
+praisonaiagents/task/task.py,sha256=imqJ8wzZzVyUSym2EyF2tC-vAsV1UdfI_P3YM5mqAiw,20786
+praisonaiagents/tools/README.md,sha256=bIQGTSqQbC8l_UvTAnKbnh1TxrybSFGbCqxnhvDwkE4,4450
 praisonaiagents/tools/__init__.py,sha256=Rrgi7_3-yLHpfBB81WUi0-wD_wb_BsukwHVdjDYAF-0,9316
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
@@ -33,6 +38,7 @@ praisonaiagents/tools/json_tools.py,sha256=ApUYNuQ1qnbmYNCxSlx6Tth_H1yo8mhWtZ7Rr
 praisonaiagents/tools/newspaper_tools.py,sha256=NyhojNPeyULBGcAWGOT1X70qVkh3FgZrpH-S7PEmrwI,12667
 praisonaiagents/tools/pandas_tools.py,sha256=yzCeY4jetKrFIRA15Tr5OQ5d94T8DaSpzglx2UiWfPs,11092
 praisonaiagents/tools/python_tools.py,sha256=puqLANl5YaG1YG8ixkl_MgWayF7uj5iXUEE15UYwIZE,13513
+praisonaiagents/tools/searxng_tools.py,sha256=LzxFenzGlSBxnckEPwtEZYemAkU8FUflbFbHf5IZE7o,3159
 praisonaiagents/tools/shell_tools.py,sha256=6IlnFkNg04tVxQVM_fYgscIWLtcgIikpEi3olB1THuA,9431
 praisonaiagents/tools/spider_tools.py,sha256=lrZnT1V1BC46We-AzBrDB1Ryifr3KKGmYNntMsScU7w,15094
 praisonaiagents/tools/test.py,sha256=UHOTNrnMo0_H6I2g48re1WNZkrR7f6z25UnlWxiOSbM,1600
@@ -42,7 +48,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.99.dist-info/METADATA,sha256=nwlbhRlDcuelH3q-qUQS1jaEPb_CeGL849Epd6NonJM,1452
-praisonaiagents-0.0.99.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.99.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.99.dist-info/RECORD,,
+praisonaiagents-0.0.101.dist-info/METADATA,sha256=E7LFE0liQmrpsCnURK80ynkYPxMKuNTTSJM4YKUS57o,1503
+praisonaiagents-0.0.101.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.101.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.101.dist-info/RECORD,,