praisonaiagents 0.0.141__tar.gz → 0.0.143__tar.gz

{praisonaiagents-0.0.141 → praisonaiagents-0.0.143}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.141
+Version: 0.0.143
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10
@@ -32,6 +32,9 @@ Requires-Dist: fastapi>=0.115.0; extra == "api"
 Requires-Dist: uvicorn>=0.34.0; extra == "api"
 Provides-Extra: telemetry
 Requires-Dist: posthog>=3.0.0; extra == "telemetry"
+Provides-Extra: mongodb
+Requires-Dist: pymongo>=4.6.3; extra == "mongodb"
+Requires-Dist: motor>=3.4.0; extra == "mongodb"
 Provides-Extra: all
 Requires-Dist: praisonaiagents[memory]; extra == "all"
 Requires-Dist: praisonaiagents[knowledge]; extra == "all"
@@ -40,3 +43,4 @@ Requires-Dist: praisonaiagents[llm]; extra == "all"
 Requires-Dist: praisonaiagents[mcp]; extra == "all"
 Requires-Dist: praisonaiagents[api]; extra == "all"
 Requires-Dist: praisonaiagents[telemetry]; extra == "all"
+Requires-Dist: praisonaiagents[mongodb]; extra == "all"

{praisonaiagents-0.0.141 → praisonaiagents-0.0.143}/praisonaiagents/__init__.py

@@ -34,7 +34,13 @@ from .tools.tools import Tools
 from .agents.autoagents import AutoAgents
 from .knowledge.knowledge import Knowledge
 from .knowledge.chunking import Chunking
-from .mcp.mcp import MCP
+# MCP support (optional)
+try:
+    from .mcp.mcp import MCP
+    _mcp_available = True
+except ImportError:
+    _mcp_available = False
+    MCP = None
 from .session import Session
 from .memory.memory import Memory
 from .guardrails import GuardrailResult, LLMGuardrail
@@ -124,7 +130,6 @@ __all__ = [
     'async_display_callbacks',
     'Knowledge',
     'Chunking',
-    'MCP',
     'GuardrailResult',
     'LLMGuardrail',
     'Handoff',
@@ -137,4 +142,8 @@ __all__ = [
     'disable_telemetry',
     'MinimalTelemetry',
     'TelemetryCollector'
-] 
+]
+
+# Add MCP to __all__ if available
+if _mcp_available:
+    __all__.append('MCP') 

{praisonaiagents-0.0.141 → praisonaiagents-0.0.143}/praisonaiagents/agent/agent.py

@@ -354,6 +354,8 @@ class Agent:
         self.instructions = instructions
         # Check for model name in environment variable if not provided
         self._using_custom_llm = False
+        # Flag to track if final result has been displayed to prevent duplicates
+        self._final_display_shown = False
         
         # Store OpenAI client parameters for lazy initialization
         self._openai_api_key = api_key
@@ -1173,18 +1175,23 @@ Your Goal: {self.goal}"""
                 task_description=task_description, 
                 task_id=task_id
             )
-        # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-        if self.verbose and not self._using_custom_llm:
+        # Always display final interaction when verbose is True to ensure consistent formatting
+        # This ensures both OpenAI and custom LLM providers (like Gemini) show formatted output
+        if self.verbose and not self._final_display_shown:
             display_interaction(prompt, response, markdown=self.markdown, 
                               generation_time=generation_time, console=self.console,
                               agent_name=self.name,
                               agent_role=self.role,
                               agent_tools=[t.__name__ for t in self.tools] if self.tools else None,
-                              task_name=task_name,
-                              task_description=task_description,
-                              task_id=task_id)
+                              task_name=None,  # Not available in this context
+                              task_description=None,  # Not available in this context
+                              task_id=None)  # Not available in this context
+            self._final_display_shown = True
 
     def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False, stream=True, task_name=None, task_description=None, task_id=None):
+        # Reset the final display flag for each new conversation
+        self._final_display_shown = False
+        
         # Log all parameter values when in debug mode
         if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
             param_info = {
@@ -1376,6 +1383,23 @@ Your Goal: {self.goal}"""
                                 # Rollback chat history on guardrail failure
                                 self.chat_history = self.chat_history[:chat_history_length]
                                 return None
+                                # Only consider satisfactory after minimum reflections
+                            if reflection_output.satisfactory == "yes" and reflection_count >= self.min_reflect - 1:
+                                if self.verbose:
+                                    display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections", console=self.console)
+                                # User message already added before LLM call via _build_messages
+                                self.chat_history.append({"role": "assistant", "content": response_text})
+                                # Apply guardrail validation after satisfactory reflection
+                                try:
+                                    validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools, task_name, task_description, task_id)
+                                    # Execute callback after validation
+                                    self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time, task_name, task_description, task_id)
+                                    return validated_response
+                                except Exception as e:
+                                    logging.error(f"Agent {self.name}: Guardrail validation failed after reflection: {e}")
+                                    # Rollback chat history on guardrail failure
+                                    self.chat_history = self.chat_history[:chat_history_length]
+                                    return None
 
                         if not self.self_reflect:
                             # User message already added before LLM call via _build_messages
@@ -1533,6 +1557,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
     async def achat(self, prompt: str, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False, task_name=None, task_description=None, task_id=None):
         """Async version of chat method with self-reflection support.""" 
+        # Reset the final display flag for each new conversation
+        self._final_display_shown = False
+        
         # Log all parameter values when in debug mode
         if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
             param_info = {

{praisonaiagents-0.0.141 → praisonaiagents-0.0.143}/praisonaiagents/agent/image_agent.py

@@ -151,9 +151,23 @@ class ImageAgent(Agent):
         # Use the model name in config
         config['model'] = model_name
 
-        # Check if we're using a Gemini model and remove unsupported parameters
-        if 'gemini' in model_name.lower():
-            # Gemini models don't support response_format parameter
+        # Filter parameters based on the provider to avoid unsupported parameter errors
+        custom_llm_provider = None
+        try:
+            import litellm
+            _, custom_llm_provider, _, _ = litellm.get_llm_provider(model=model_name)
+        except (ImportError, AttributeError, ValueError, TypeError, Exception) as e:
+            # Log the specific error for debugging but continue with string-based fallback
+            # Include generic Exception to catch provider-specific errors like BadRequestError
+            logging.debug(f"Provider detection failed for model '{model_name}': {e}")
+        
+        if custom_llm_provider == "vertex_ai":
+            # Vertex AI only supports 'n' and 'size' parameters for image generation
+            supported_params = ['n', 'size', 'model']
+            config = {k: v for k, v in config.items() if k in supported_params}
+        elif custom_llm_provider == "gemini" or (custom_llm_provider is None and 'gemini' in model_name.lower()):
+            # Gemini provider doesn't support response_format parameter
+            # Apply this filter if provider is explicitly 'gemini' or as fallback for gemini models
             config.pop('response_format', None)
 
         with Progress(
@@ -165,9 +179,10 @@ class ImageAgent(Agent):
                 # Add a task for image generation
                 task = progress.add_task(f"[cyan]Generating image with {model_name}...", total=None)
                 
-                # Use litellm's image generation
+                # Use litellm's image generation with parameter dropping enabled as safety net
                 response = self.litellm(
                     prompt=prompt,
+                    drop_params=True,
                     **config
                 )
                 

{praisonaiagents-0.0.141 → praisonaiagents-0.0.143}/praisonaiagents/knowledge/knowledge.py

@@ -2,6 +2,7 @@ import os
 import logging
 import uuid
 import time
+from datetime import datetime
 from .chunking import Chunking
 from functools import cached_property
 from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
@@ -47,6 +48,342 @@ class CustomMemory:
             "event": "ADD"
         }]
 
+class MongoDBMemory:
+    """MongoDB-based memory store for knowledge management."""
+    
+    def __init__(self, config):
+        self.config = config
+        self.vector_store_config = config.get("vector_store", {}).get("config", {})
+        self.connection_string = self.vector_store_config.get("connection_string", "mongodb://localhost:27017/")
+        self.database_name = self.vector_store_config.get("database", "praisonai")
+        self.collection_name = self.vector_store_config.get("collection", "knowledge_base")
+        self.use_vector_search = self.vector_store_config.get("use_vector_search", True)
+        
+        # Initialize MongoDB client
+        self._init_mongodb()
+        
+        # Initialize embedding model
+        self._init_embedding_model()
+    
+    def _init_mongodb(self):
+        """Initialize MongoDB client and collection."""
+        try:
+            from pymongo import MongoClient
+            
+            self.client = MongoClient(
+                self.connection_string,
+                maxPoolSize=50,
+                retryWrites=True,
+                retryReads=True
+            )
+            
+            # Test connection
+            self.client.admin.command('ping')
+            
+            # Setup database and collection
+            self.db = self.client[self.database_name]
+            self.collection = self.db[self.collection_name]
+            
+            # Create indexes
+            self._create_indexes()
+            
+        except Exception as e:
+            raise Exception(f"Failed to initialize MongoDB: {e}")
+    
+    def _init_embedding_model(self):
+        """Initialize embedding model from config."""
+        try:
+            # Set up embedding model based on config
+            embedder_config = self.config.get("embedder", {})
+            if embedder_config.get("provider") == "openai":
+                import openai
+                self.embedding_model = openai.OpenAI()
+                self.embedding_model_name = embedder_config.get("config", {}).get("model", "text-embedding-3-small")
+            else:
+                # Default to OpenAI
+                import openai
+                self.embedding_model = openai.OpenAI()
+                self.embedding_model_name = "text-embedding-3-small"
+        except Exception as e:
+            raise Exception(f"Failed to initialize embedding model: {e}")
+    
+    def _get_embedding_dimensions(self, model_name: str) -> int:
+        """Get embedding dimensions based on model name."""
+        # Common embedding model dimensions
+        model_dimensions = {
+            "text-embedding-3-small": 1536,
+            "text-embedding-3-large": 3072,
+            "text-embedding-ada-002": 1536,
+            "text-embedding-002": 1536,
+            # Add more models as needed
+        }
+        
+        # Check if model name contains known model identifiers
+        for model_key, dimensions in model_dimensions.items():
+            if model_key in model_name.lower():
+                return dimensions
+        
+        # Default to 1536 for unknown models (OpenAI standard)
+        return 1536
+    
+    def _create_indexes(self):
+        """Create necessary indexes for MongoDB."""
+        try:
+            # Text search index
+            self.collection.create_index([("content", "text")])
+            
+            # Metadata indexes
+            self.collection.create_index([("metadata.filename", 1)])
+            self.collection.create_index([("created_at", -1)])
+            
+            # Vector search index for Atlas (if enabled)
+            if self.use_vector_search:
+                self._create_vector_index()
+                
+        except Exception as e:
+            logging.warning(f"Could not create MongoDB indexes: {e}")
+    
+    def _create_vector_index(self):
+        """Create vector search index for Atlas Vector Search."""
+        try:
+            vector_index_def = {
+                "mappings": {
+                    "dynamic": True,
+                    "fields": {
+                        "embedding": {
+                            "type": "knnVector",
+                            "dimensions": self._get_embedding_dimensions(self.embedding_model_name),
+                            "similarity": "cosine"
+                        }
+                    }
+                }
+            }
+            
+            self.collection.create_search_index(vector_index_def, "vector_index")
+            
+        except Exception as e:
+            logging.warning(f"Could not create vector search index: {e}")
+    
+    def _get_embedding(self, text):
+        """Get embedding for text."""
+        try:
+            response = self.embedding_model.embeddings.create(
+                input=text,
+                model=self.embedding_model_name
+            )
+            return response.data[0].embedding
+        except Exception as e:
+            logging.error(f"Error getting embedding: {e}")
+            return None
+    
+    def add(self, messages, user_id=None, agent_id=None, run_id=None, metadata=None):
+        """Add memory to MongoDB."""
+        try:
+            # Handle different message formats
+            if isinstance(messages, list):
+                content = "\n".join([msg.get("content", str(msg)) if isinstance(msg, dict) else str(msg) for msg in messages])
+            else:
+                content = str(messages)
+            
+            # Generate embedding
+            embedding = self._get_embedding(content) if self.use_vector_search else None
+            
+            # Create document
+            doc = {
+                "content": content,
+                "metadata": metadata or {},
+                "user_id": user_id,
+                "agent_id": agent_id,
+                "run_id": run_id,
+                "created_at": datetime.utcnow(),
+                "memory_type": "knowledge"
+            }
+            
+            if embedding:
+                doc["embedding"] = embedding
+            
+            # Insert document
+            result = self.collection.insert_one(doc)
+            
+            return [{
+                "id": str(result.inserted_id),
+                "memory": content,
+                "event": "ADD"
+            }]
+            
+        except Exception as e:
+            logging.error(f"Error adding memory to MongoDB: {e}")
+            return []
+    
+    def search(self, query, user_id=None, agent_id=None, run_id=None, rerank=False, **kwargs):
+        """Search memories in MongoDB."""
+        try:
+            results = []
+            
+            # Vector search if enabled
+            if self.use_vector_search:
+                embedding = self._get_embedding(query)
+                if embedding:
+                    pipeline = [
+                        {
+                            "$vectorSearch": {
+                                "index": "vector_index",
+                                "path": "embedding",
+                                "queryVector": embedding,
+                                "numCandidates": kwargs.get("limit", 10) * 10,
+                                "limit": kwargs.get("limit", 10)
+                            }
+                        },
+                        {
+                            "$addFields": {
+                                "score": {"$meta": "vectorSearchScore"}
+                            }
+                        }
+                    ]
+                    
+                    # Add filters if provided
+                    if user_id or agent_id or run_id:
+                        match_filter = {}
+                        if user_id:
+                            match_filter["user_id"] = user_id
+                        if agent_id:
+                            match_filter["agent_id"] = agent_id
+                        if run_id:
+                            match_filter["run_id"] = run_id
+                        
+                        pipeline.append({"$match": match_filter})
+                    
+                    for doc in self.collection.aggregate(pipeline):
+                        results.append({
+                            "id": str(doc["_id"]),
+                            "memory": doc["content"],
+                            "metadata": doc.get("metadata", {}),
+                            "score": doc.get("score", 1.0)
+                        })
+            
+            # Fallback to text search
+            if not results:
+                search_filter = {"$text": {"$search": query}}
+                
+                # Add additional filters
+                if user_id:
+                    search_filter["user_id"] = user_id
+                if agent_id:
+                    search_filter["agent_id"] = agent_id
+                if run_id:
+                    search_filter["run_id"] = run_id
+                
+                for doc in self.collection.find(search_filter).limit(kwargs.get("limit", 10)):
+                    results.append({
+                        "id": str(doc["_id"]),
+                        "memory": doc["content"],
+                        "metadata": doc.get("metadata", {}),
+                        "score": 1.0
+                    })
+            
+            return results
+            
+        except Exception as e:
+            logging.error(f"Error searching MongoDB: {e}")
+            return []
+    
+    def get_all(self, user_id=None, agent_id=None, run_id=None):
+        """Get all memories from MongoDB."""
+        try:
+            search_filter = {}
+            if user_id:
+                search_filter["user_id"] = user_id
+            if agent_id:
+                search_filter["agent_id"] = agent_id
+            if run_id:
+                search_filter["run_id"] = run_id
+            
+            results = []
+            for doc in self.collection.find(search_filter):
+                results.append({
+                    "id": str(doc["_id"]),
+                    "memory": doc["content"],
+                    "metadata": doc.get("metadata", {}),
+                    "created_at": doc.get("created_at")
+                })
+            
+            return results
+            
+        except Exception as e:
+            logging.error(f"Error getting all memories from MongoDB: {e}")
+            return []
+    
+    def get(self, memory_id):
+        """Get a specific memory by ID."""
+        try:
+            from bson import ObjectId
+            doc = self.collection.find_one({"_id": ObjectId(memory_id)})
+            if doc:
+                return {
+                    "id": str(doc["_id"]),
+                    "memory": doc["content"],
+                    "metadata": doc.get("metadata", {}),
+                    "created_at": doc.get("created_at")
+                }
+            return None
+            
+        except Exception as e:
+            logging.error(f"Error getting memory from MongoDB: {e}")
+            return None
+    
+    def update(self, memory_id, data):
+        """Update a memory."""
+        try:
+            from bson import ObjectId
+            result = self.collection.update_one(
+                {"_id": ObjectId(memory_id)},
+                {"$set": {"content": data, "updated_at": datetime.utcnow()}}
+            )
+            return result.modified_count > 0
+            
+        except Exception as e:
+            logging.error(f"Error updating memory in MongoDB: {e}")
+            return False
+    
+    def delete(self, memory_id):
+        """Delete a memory."""
+        try:
+            from bson import ObjectId
+            result = self.collection.delete_one({"_id": ObjectId(memory_id)})
+            return result.deleted_count > 0
+            
+        except Exception as e:
+            logging.error(f"Error deleting memory from MongoDB: {e}")
+            return False
+    
+    def delete_all(self, user_id=None, agent_id=None, run_id=None):
+        """Delete all memories."""
+        try:
+            search_filter = {}
+            if user_id:
+                search_filter["user_id"] = user_id
+            if agent_id:
+                search_filter["agent_id"] = agent_id
+            if run_id:
+                search_filter["run_id"] = run_id
+            
+            result = self.collection.delete_many(search_filter)
+            return result.deleted_count
+            
+        except Exception as e:
+            logging.error(f"Error deleting all memories from MongoDB: {e}")
+            return 0
+    
+    def reset(self):
+        """Reset all memories."""
+        try:
+            result = self.collection.delete_many({})
+            return result.deleted_count
+            
+        except Exception as e:
+            logging.error(f"Error resetting MongoDB memories: {e}")
+            return 0
+
 class Knowledge:
     def __init__(self, config=None, verbose=None):
         self._config = config
@@ -119,8 +456,20 @@ class Knowledge:
             if "vector_store" in self._config:
                 if "provider" in self._config["vector_store"]:
                     base_config["vector_store"]["provider"] = self._config["vector_store"]["provider"]
+                    
+                    # Special handling for MongoDB vector store
+                    if self._config["vector_store"]["provider"] == "mongodb":
+                        base_config["vector_store"] = {
+                            "provider": "mongodb",
+                            "config": {
+                                "connection_string": self._config["vector_store"]["config"].get("connection_string", "mongodb://localhost:27017/"),
+                                "database": self._config["vector_store"]["config"].get("database", "praisonai"),
+                                "collection": self._config["vector_store"]["config"].get("collection", "knowledge_base"),
+                                "use_vector_search": self._config["vector_store"]["config"].get("use_vector_search", True)
+                            }
+                        }
             
-                if "config" in self._config["vector_store"]:
+                if "config" in self._config["vector_store"] and self._config["vector_store"]["provider"] != "mongodb":
                     config_copy = self._config["vector_store"]["config"].copy()
                     # Only exclude client as it's managed internally
                     if "client" in config_copy:
@@ -146,6 +495,16 @@ class Knowledge:
 
     @cached_property
     def memory(self):
+        # Check if MongoDB provider is specified
+        if (self.config.get("vector_store", {}).get("provider") == "mongodb"):
+            try:
+                return MongoDBMemory(self.config)
+            except Exception as e:
+                logger.error(f"Failed to initialize MongoDB memory: {e}")
+                # Fall back to default memory
+                pass
+        
+        # Default Mem0 memory
         try:
             return CustomMemory.from_config(self.config)
         except (NotImplementedError, ValueError) as e:

{praisonaiagents-0.0.141 → praisonaiagents-0.0.143}/praisonaiagents/llm/llm.py

@@ -329,16 +329,29 @@ class LLM:
         # For Ollama, always generate summary when we have tool results
         # This prevents infinite loops caused by empty/minimal responses
             
-        # Build tool summary efficiently
-        summary_lines = ["Based on the tool execution results:"]
-        for i, result in enumerate(tool_results):
+        # Build tool summary more naturally to match OpenAI-style responses
+        if len(tool_results) == 1:
+            # Single tool result - create natural response
+            result = tool_results[0]
             if isinstance(result, dict) and 'result' in result:
-                function_name = result.get('function_name', 'Tool')
-                summary_lines.append(f"- {function_name}: {result['result']}")
+                return str(result['result'])
             else:
-                summary_lines.append(f"- Tool {i+1}: {result}")
-        
-        return "\n".join(summary_lines)
+                return str(result)
+        else:
+            # Multiple tool results - create coherent summary
+            summary_lines = []
+            for i, result in enumerate(tool_results):
+                if isinstance(result, dict) and 'result' in result:
+                    function_name = result.get('function_name', 'Tool')
+                    summary_lines.append(f"{function_name}: {result['result']}")
+                else:
+                    summary_lines.append(f"Tool {i+1}: {result}")
+            
+            # Create more natural summary text
+            if len(summary_lines) == 2:
+                return f"{summary_lines[0]}. {summary_lines[1]}."
+            else:
+                return "Based on the tool execution: " + ". ".join(summary_lines) + "."
 
     def _format_ollama_tool_result_message(self, function_name: str, tool_result: Any) -> Dict[str, str]:
         """
@@ -1173,6 +1186,7 @@ class LLM:
                             final_response_text = response_text.strip()
                             break
                         
+                        
                         # Special handling for Ollama to prevent infinite loops
                         # Only generate summary after multiple iterations to allow sequential execution
                         should_break, tool_summary_text, iteration_count = self._handle_ollama_sequential_logic(
@@ -1198,6 +1212,17 @@ class LLM:
                         continue
                     else:
                         # No tool calls, we're done with this iteration
+                        
+                        # Special early stopping logic for Ollama when tool results are available
+                        # Ollama often provides empty responses after successful tool execution
+                        if (self._is_ollama_provider() and accumulated_tool_results and iteration_count >= 1 and 
+                            (not response_text or response_text.strip() == "")):
+                            # Generate coherent response from tool results
+                            tool_summary = self._generate_ollama_tool_summary(accumulated_tool_results, response_text)
+                            if tool_summary:
+                                final_response_text = tool_summary
+                                break
+                        
                         # If we've executed tools in previous iterations, this response contains the final answer
                         if iteration_count > 0 and not final_response_text:
                             final_response_text = response_text.strip() if response_text else ""
@@ -1956,6 +1981,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         final_response_text = response_text.strip()
                         break
                     
+                    
                     # Special handling for Ollama to prevent infinite loops
                     # Only generate summary after multiple iterations to allow sequential execution
                     should_break, tool_summary_text, iteration_count = self._handle_ollama_sequential_logic(
@@ -1981,6 +2007,17 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     continue
                 else:
                     # No tool calls, we're done with this iteration
+                    
+                    # Special early stopping logic for Ollama when tool results are available
+                    # Ollama often provides empty responses after successful tool execution
+                    if (self._is_ollama_provider() and accumulated_tool_results and iteration_count >= 1 and 
+                        (not response_text or response_text.strip() == "")):
+                        # Generate coherent response from tool results
+                        tool_summary = self._generate_ollama_tool_summary(accumulated_tool_results, response_text)
+                        if tool_summary:
+                            final_response_text = tool_summary
+                            break
+                    
                     # If we've executed tools in previous iterations, this response contains the final answer
                     if iteration_count > 0 and not final_response_text:
                         final_response_text = response_text.strip()