praisonaiagents 0.0.142__tar.gz → 0.0.143__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.142
+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.142 → 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.142 → praisonaiagents-0.0.143}/praisonaiagents/agent/agent.py

@@ -1383,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

{praisonaiagents-0.0.142 → 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.142 → 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.142 → praisonaiagents-0.0.143}/praisonaiagents/llm/openai_client.py

@@ -1049,6 +1049,150 @@ class OpenAIClient:
                 break
         
         return final_response
+        
+    def chat_completion_with_tools_stream(
+        self,
+        messages: List[Dict[str, Any]],
+        model: str = "gpt-4o",
+        temperature: float = 0.7,
+        tools: Optional[List[Any]] = None,
+        execute_tool_fn: Optional[Callable] = None,
+        reasoning_steps: bool = False,
+        verbose: bool = True,
+        max_iterations: int = 10,
+        **kwargs
+    ):
+        """
+        Create a streaming chat completion with tool support.
+        
+        This method yields chunks of the response as they are generated,
+        enabling real-time streaming to the user.
+        
+        Args:
+            messages: List of message dictionaries
+            model: Model to use
+            temperature: Temperature for generation
+            tools: List of tools (can be callables, dicts, or strings)
+            execute_tool_fn: Function to execute tools
+            reasoning_steps: Whether to show reasoning
+            verbose: Whether to show verbose output
+            max_iterations: Maximum tool calling iterations
+            **kwargs: Additional API parameters
+            
+        Yields:
+            String chunks of the response as they are generated
+        """
+        # Format tools for OpenAI API
+        formatted_tools = self.format_tools(tools)
+        
+        # Continue tool execution loop until no more tool calls are needed
+        iteration_count = 0
+        
+        while iteration_count < max_iterations:
+            try:
+                # Create streaming response
+                response_stream = self._sync_client.chat.completions.create(
+                    model=model,
+                    messages=messages,
+                    temperature=temperature,
+                    tools=formatted_tools if formatted_tools else None,
+                    stream=True,
+                    **kwargs
+                )
+                
+                full_response_text = ""
+                reasoning_content = ""
+                chunks = []
+                
+                # Stream the response chunk by chunk
+                for chunk in response_stream:
+                    chunks.append(chunk)
+                    if chunk.choices and chunk.choices[0].delta.content:
+                        content = chunk.choices[0].delta.content
+                        full_response_text += content
+                        yield content
+                    
+                    # Handle reasoning content if enabled
+                    if reasoning_steps and chunk.choices and hasattr(chunk.choices[0].delta, "reasoning_content"):
+                        rc = chunk.choices[0].delta.reasoning_content
+                        if rc:
+                            reasoning_content += rc
+                            yield f"[Reasoning: {rc}]"
+                
+                # Process the complete response to check for tool calls
+                final_response = process_stream_chunks(chunks)
+                
+                if not final_response:
+                    return
+                
+                # Check for tool calls
+                tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
+                
+                if tool_calls and execute_tool_fn:
+                    # Convert ToolCall dataclass objects to dict for JSON serialization
+                    serializable_tool_calls = []
+                    for tc in tool_calls:
+                        if isinstance(tc, ToolCall):
+                            # Convert dataclass to dict
+                            serializable_tool_calls.append({
+                                "id": tc.id,
+                                "type": tc.type,
+                                "function": tc.function
+                            })
+                        else:
+                            # Already an OpenAI object, keep as is
+                            serializable_tool_calls.append(tc)
+                    
+                    messages.append({
+                        "role": "assistant", 
+                        "content": final_response.choices[0].message.content,
+                        "tool_calls": serializable_tool_calls
+                    })
+                    
+                    for tool_call in tool_calls:
+                        # Handle both ToolCall dataclass and OpenAI object
+                        try:
+                            if isinstance(tool_call, ToolCall):
+                                function_name = tool_call.function["name"]
+                                arguments = json.loads(tool_call.function["arguments"])
+                            else:
+                                function_name = tool_call.function.name
+                                arguments = json.loads(tool_call.function.arguments)
+                        except json.JSONDecodeError as e:
+                            if verbose:
+                                yield f"\n[Error parsing arguments for {function_name if 'function_name' in locals() else 'unknown function'}: {str(e)}]"
+                            continue
+                        
+                        if verbose:
+                            yield f"\n[Calling function: {function_name}]"
+                        
+                        # Execute the tool with error handling
+                        try:
+                            tool_result = execute_tool_fn(function_name, arguments)
+                            results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
+                        except Exception as e:
+                            results_str = f"Error executing function: {str(e)}"
+                            if verbose:
+                                yield f"\n[Function error: {str(e)}]"
+                        
+                        if verbose:
+                            yield f"\n[Function result: {results_str}]"
+                        
+                        messages.append({
+                            "role": "tool",
+                            "tool_call_id": tool_call.id if hasattr(tool_call, 'id') else tool_call['id'],
+                            "content": results_str
+                        })
+                    
+                    # Continue the loop to allow more tool calls
+                    iteration_count += 1
+                else:
+                    # No tool calls, we're done
+                    break
+                    
+            except Exception as e:
+                yield f"Error: {str(e)}"
+                break
     
     def parse_structured_output(
         self,