feat: add MongoDB integration examples and context engineering improvements

fix: remove verbose knowledge headers from AI agent prompts

docker/Dockerfile

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.2.71" \
+    "praisonai>=2.2.72" \
     "praisonai[api]" \
     gunicorn \
     markdown

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.71" \
+    "praisonai>=2.2.72" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.71" \
+    "praisonai>=2.2.72" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.71" \
+    "praisonai>=2.2.72" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

docker/README.md

@@ -121,7 +121,7 @@ healthcheck:
 ## 📦 Package Versions
 
 All Docker images use consistent, up-to-date versions:
-- PraisonAI: `>=2.2.71`
+- PraisonAI: `>=2.2.72`
 - PraisonAI Agents: `>=0.0.92`
 - Python: `3.11-slim`
 
@@ -218,7 +218,7 @@ docker-compose up -d
 ### Version Pinning
 To use specific versions, update the Dockerfile:
 ```dockerfile
-RUN pip install "praisonai==2.2.71" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.72" "praisonaiagents==0.0.92"
 ```
 
 ## 🌐 Production Deployment

examples/python/agents/context-agent.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+Context Agent Example - Basic Usage
+
+This example demonstrates how to use the ContextAgent for automated context generation.
+The ContextAgent implements Context Engineering principles to generate comprehensive
+context for AI coding assistants, enabling first-try implementation success.
+
+Key features demonstrated:
+- Basic ContextAgent instantiation
+- Codebase pattern analysis
+- Context document generation  
+- Validation loop creation
+- Prompt enhancement with context
+- PRP (Product Requirements Prompt) generation
+"""
+
+import sys
+from pathlib import Path
+
+# Add the src directory to Python path for imports
+project_root = Path(__file__).parent.parent.parent.parent / "src" / "praisonai-agents"
+sys.path.insert(0, str(project_root))
+
+from praisonaiagents import create_context_agent
+
+def demonstrate_basic_context_generation():
+    """Demonstrate basic context generation capabilities."""
+    print("🔧 Context Engineering Example: Basic Usage")
+    print("=" * 60)
+    
+    # Create a ContextAgent using the factory function
+    context_agent = create_context_agent(
+        llm="gpt-4o-mini",
+        name="Basic Context Engineer",
+        verbose=True
+    )
+    
+    # Example 1: Analyze codebase patterns
+    print("\n📁 Example 1: Analyzing Codebase Patterns")
+    print("-" * 40)
+    
+    # Use current project as example (adjust path as needed)
+    project_path = str(project_root)
+    analysis = context_agent.analyze_codebase_patterns(
+        project_path=project_path,
+        file_patterns=["*.py"]
+    )
+    
+    print(f"✅ Analyzed project at: {project_path}")
+    print(f"   Project structure: {len(analysis.get('project_structure', {}).get('directories', []))} directories")
+    print(f"   Code patterns identified: {len(analysis.get('code_patterns', {}))}")
+    print(f"   Architecture: {analysis.get('architecture_insights', {}).get('primary_pattern', 'Unknown')}")
+    
+    # Example 2: Generate context document
+    print("\n📄 Example 2: Generating Context Document")
+    print("-" * 40)
+    
+    feature_request = "Add user authentication system with JWT tokens and role-based access control"
+    context_doc = context_agent.generate_context_document(
+        project_path=project_path,
+        requirements=feature_request,
+        analysis=analysis
+    )
+    
+    print(f"✅ Generated context document for: {feature_request}")
+    print(f"   Document length: {len(context_doc)} characters")
+    print(f"   Contains architecture patterns: {'Architecture Patterns' in context_doc}")
+    print(f"   Contains validation criteria: {'Validation Criteria' in context_doc}")
+    
+    # Example 3: Create validation loop
+    print("\n✅ Example 3: Creating Validation Loop")
+    print("-" * 40)
+    
+    success_criteria = [
+        "Authentication system accepts valid JWT tokens",
+        "Role-based access control blocks unauthorized users", 
+        "User registration and login endpoints work correctly",
+        "Password hashing follows security best practices",
+        "Session management handles token expiration"
+    ]
+    
+    validation_config = context_agent.create_validation_loop(
+        implementation_requirements=feature_request,
+        success_criteria=success_criteria
+    )
+    
+    print(f"✅ Created validation loop with {len(validation_config['validation_steps'])} steps")
+    print(f"   Success criteria: {len(success_criteria)}")
+    print(f"   Executable tests: {len(validation_config['executable_tests'])}")
+    print(f"   Quality gates: {len(validation_config['quality_gates'])}")
+    
+    # Example 4: Enhance prompt with context
+    print("\n🚀 Example 4: Enhancing Prompt with Context")
+    print("-" * 40)
+    
+    basic_prompt = "Implement user authentication"
+    enhanced_prompt = context_agent.enhance_prompt_with_context(
+        base_prompt=basic_prompt,
+        context_data=analysis
+    )
+    
+    print(f"✅ Enhanced prompt from {len(basic_prompt)} to {len(enhanced_prompt)} characters")
+    print(f"   Original: '{basic_prompt}'")
+    print("   Enhanced includes: Context Engineering, Implementation Context, Quality Requirements")
+    
+    # Example 5: Generate PRP (Product Requirements Prompt)
+    print("\n📋 Example 5: Generating PRP")
+    print("-" * 40)
+    
+    documentation_links = [
+        "https://jwt.io/introduction/",
+        "https://fastapi.tiangolo.com/tutorial/security/",
+        "https://passlib.readthedocs.io/en/stable/"
+    ]
+    
+    prp = context_agent.generate_prp(
+        feature_request=feature_request,
+        context_analysis=analysis,
+        documentation_links=documentation_links
+    )
+    
+    print("✅ Generated comprehensive PRP")
+    print(f"   PRP length: {len(prp)} characters")
+    print(f"   Contains feature request: {feature_request in prp}")
+    print(f"   Contains documentation links: {len(documentation_links)} links included")
+    print(f"   Contains implementation blueprint: {'Implementation Blueprint' in prp}")
+    print(f"   Confidence score: {'9/10' in prp}")
+
+def demonstrate_context_agent_as_tool():
+    """Demonstrate using ContextAgent as a tool in a multi-agent workflow."""
+    print("\n🔗 Context Engineering Example: Multi-Agent Integration")
+    print("=" * 60)
+    
+    # Create ContextAgent
+    context_agent = create_context_agent(llm="gpt-4o-mini")
+    
+    # Example scenario: Product planning workflow
+    project_path = str(project_root)
+    feature_request = "Build a real-time chat system with WebSocket support"
+    
+    # Step 1: Context analysis
+    print("\n1️⃣ Step 1: Context Analysis")
+    analysis = context_agent.analyze_codebase_patterns(project_path)
+    print(f"✅ Analyzed codebase architecture and patterns")
+    
+    # Step 2: Generate implementation blueprint
+    print("\n2️⃣ Step 2: Implementation Blueprint")
+    blueprint = context_agent.create_implementation_blueprint(feature_request, analysis)
+    print(f"✅ Created implementation blueprint with {len(blueprint['implementation_steps'])} steps")
+    
+    # Step 3: Generate comprehensive PRP
+    print("\n3️⃣ Step 3: Generate PRP")
+    prp = context_agent.generate_prp(feature_request, analysis)  # Generated PRP for implementation guidance
+    print(f"✅ Generated PRP for implementation guidance")
+    
+    # Step 4: Create validation framework
+    print("\n4️⃣ Step 4: Validation Framework")
+    criteria = [
+        "WebSocket connections establish successfully",
+        "Messages broadcast to all connected clients",
+        "Chat history persists and loads correctly",
+        "User authentication works with WebSocket",
+        "Connection handling is robust with reconnection"
+    ]
+    validation = context_agent.create_validation_loop(feature_request, criteria)  # Validation framework for QA
+    print(f"✅ Created validation framework with {len(criteria)} criteria")
+    
+    print("\n🎯 Context Engineering Workflow Complete!")
+    print(f"   Feature: {feature_request}")
+    print("   Implementation ready with comprehensive context")
+    print("   Validation criteria defined for quality assurance")
+
+def show_context_engineering_benefits():
+    """Demonstrate the benefits of Context Engineering vs traditional approaches."""
+    print("\n📊 Context Engineering Benefits")
+    print("=" * 60)
+    
+    # Traditional prompt engineering approach
+    print("\n❌ Traditional Prompt Engineering:")
+    traditional_prompt = "Create a user authentication system"
+    print(f"   Prompt: '{traditional_prompt}'")
+    print(f"   Length: {len(traditional_prompt)} characters")
+    print(f"   Context: Minimal - relies on AI's general knowledge")
+    print(f"   Success Rate: Variable - depends on AI model's training")
+    
+    # Context Engineering approach
+    print("\n✅ Context Engineering Approach:")
+    context_agent = create_context_agent(llm="gpt-4o-mini")
+    
+    # Generate comprehensive context
+    analysis = context_agent.analyze_codebase_patterns(str(project_root))
+    enhanced_prompt = context_agent.enhance_prompt_with_context(
+        traditional_prompt, analysis
+    )
+    
+    print(f"   Enhanced Prompt Length: {len(enhanced_prompt)} characters")
+    print(f"   Context: Comprehensive - includes:")
+    print(f"     • Codebase architecture analysis")
+    print(f"     • Existing patterns and conventions")
+    print(f"     • Implementation guidance")
+    print(f"     • Quality requirements")
+    print(f"     • Validation criteria")
+    print(f"   Success Rate: Higher - AI has all necessary context")
+    
+    print(f"\n🎯 Context Engineering provides:")
+    print("   📈 10x better than prompt engineering (comprehensive vs clever wording)")
+    print("   📈 100x better than vibe coding (structured vs ad-hoc)")
+    print("   🎯 First-try implementation success through complete context")
+
+if __name__ == "__main__":
+    print("🚀 PraisonAI Context Engineering Examples")
+    print("=========================================")
+    
+    try:
+        # Run all examples
+        demonstrate_basic_context_generation()
+        demonstrate_context_agent_as_tool()
+        show_context_engineering_benefits()
+        
+        print("\n🎉 All Context Engineering examples completed successfully!")
+        print("\n💡 Key Takeaways:")
+        print("   • ContextAgent automates comprehensive context generation")
+        print("   • Context Engineering enables first-try implementation success")
+        print("   • Integration with existing PraisonAI agents is seamless")
+        print("   • Validation frameworks ensure quality and completeness")
+        
+    except Exception as e:
+        print(f"\n❌ Error running examples: {e}")
+        print("   Make sure you have the PraisonAI package installed and configured")
+        sys.exit(1)

examples/python/concepts/context-engineering-workflow.py

@@ -0,0 +1,469 @@
+#!/usr/bin/env python3
+"""
+Context Engineering Workflow - Advanced Multi-Agent Example
+
+This example demonstrates advanced Context Engineering workflows using ContextAgent
+in combination with other PraisonAI agents. It shows how Context Engineering can
+dramatically improve AI implementation success rates through comprehensive context
+generation and validation loops.
+
+Workflow demonstrated:
+1. Product Manager Agent defines requirements
+2. ContextAgent analyzes codebase and generates comprehensive context
+3. Architecture Agent designs implementation using context
+4. Developer Agent implements using context-enhanced prompts
+5. QA Agent validates using context-generated criteria
+
+This represents the full Context Engineering methodology in action.
+"""
+
+import sys
+from pathlib import Path
+
+# Add the src directory to Python path for imports
+project_root = Path(__file__).parent.parent.parent.parent / "src" / "praisonai-agents"
+sys.path.insert(0, str(project_root))
+
+from praisonaiagents import Agent, Task, PraisonAIAgents, create_context_agent
+
+class ContextEngineeringWorkflow:
+    """
+    Advanced Context Engineering workflow demonstrating the full methodology.
+    
+    This class orchestrates multiple agents using Context Engineering principles
+    to achieve higher success rates in AI-driven development tasks.
+    """
+    
+    def __init__(self, project_path: str, llm: str = "gpt-4o-mini"):
+        self.project_path = project_path
+        self.llm = llm
+        self.context_data = {}
+        self.setup_agents()
+    
+    def setup_agents(self):
+        """Setup the multi-agent team with Context Engineering support."""
+        
+        # 1. Product Manager Agent - Defines requirements
+        self.product_manager = Agent(
+            name="Product Manager",
+            role="Product Requirements Specialist",
+            goal="Define clear, comprehensive product requirements and user stories",
+            backstory="""You are an experienced product manager who specializes in 
+            creating detailed, actionable requirements. You understand that clear 
+            requirements are the foundation of successful implementation.""",
+            instructions="""
+            When defining requirements:
+            1. Be specific and measurable
+            2. Include user acceptance criteria
+            3. Consider edge cases and error scenarios
+            4. Define success metrics
+            5. Specify technical constraints
+            """,
+            llm=self.llm,
+            verbose=True
+        )
+        
+        # 2. Context Engineering Agent - Generates comprehensive context
+        self.context_engineer = create_context_agent(
+            llm=self.llm,
+            name="Context Engineering Specialist",
+            verbose=True
+        )
+        
+        # 3. Software Architect Agent - Designs implementation using context
+        self.architect = Agent(
+            name="Software Architect",
+            role="System Architecture Specialist", 
+            goal="Design robust, scalable system architecture based on comprehensive context",
+            backstory="""You are a senior software architect with expertise in 
+            designing systems that follow established patterns and best practices. 
+            You excel at creating architectures that integrate seamlessly with 
+            existing codebases.""",
+            instructions="""
+            When designing architecture:
+            1. Follow the patterns identified in the context analysis
+            2. Ensure compatibility with existing systems
+            3. Design for scalability and maintainability
+            4. Consider security and performance implications
+            5. Document architectural decisions and rationale
+            """,
+            llm=self.llm,
+            verbose=True
+        )
+        
+        # 4. Senior Developer Agent - Implements using context-enhanced guidance
+        self.developer = Agent(
+            name="Senior Developer",
+            role="Implementation Specialist",
+            goal="Implement features following context-guided best practices",
+            backstory="""You are a senior developer who excels at implementing 
+            features that follow established codebase patterns. You understand 
+            that consistency and quality are paramount.""",
+            instructions="""
+            When implementing features:
+            1. Follow the codebase patterns identified in context analysis
+            2. Maintain consistency with existing code style
+            3. Implement comprehensive error handling
+            4. Write clean, maintainable code
+            5. Follow the implementation blueprint exactly
+            """,
+            llm=self.llm,
+            verbose=True
+        )
+        
+        # 5. QA Engineer Agent - Validates using context-generated criteria
+        self.qa_engineer = Agent(
+            name="QA Engineer",
+            role="Quality Assurance Specialist",
+            goal="Ensure implementation meets all quality criteria and requirements",
+            backstory="""You are an experienced QA engineer who specializes in 
+            comprehensive testing and validation. You understand that quality 
+            is built in, not bolted on.""",
+            instructions="""
+            When validating implementations:
+            1. Use the validation criteria from context analysis
+            2. Test both happy path and edge cases
+            3. Verify integration with existing systems
+            4. Check for security vulnerabilities
+            5. Validate performance requirements
+            """,
+            llm=self.llm,
+            verbose=True
+        )
+    
+    def run_context_engineering_workflow(self, feature_request: str):
+        """
+        Execute the complete Context Engineering workflow.
+        
+        Args:
+            feature_request (str): The feature to be implemented
+            
+        Returns:
+            dict: Complete workflow results with context and implementation
+        """
+        print(f"🚀 Starting Context Engineering Workflow")
+        print(f"Feature Request: {feature_request}")
+        print("=" * 80)
+        
+        # Phase 1: Requirements Analysis
+        print("\n📋 Phase 1: Product Requirements Analysis")
+        print("-" * 50)
+        
+        requirements_task = Task(
+            name="requirements_analysis",
+            description=f"""
+            Analyze and refine the feature request: '{feature_request}'
+            
+            Create comprehensive requirements including:
+            - Detailed feature description
+            - User acceptance criteria
+            - Technical requirements
+            - Success metrics
+            - Edge cases and constraints
+            """,
+            expected_output="Comprehensive product requirements document",
+            agent=self.product_manager
+        )
+        
+        # Phase 2: Context Engineering Analysis
+        print("\n🔧 Phase 2: Context Engineering Analysis")
+        print("-" * 50)
+        
+        # Generate comprehensive context using ContextAgent
+        codebase_analysis = self.context_engineer.analyze_codebase_patterns(
+            project_path=self.project_path
+        )
+        
+        context_document = self.context_engineer.generate_context_document(
+            project_path=self.project_path,
+            requirements=feature_request,
+            analysis=codebase_analysis
+        )
+        
+        validation_framework = self.context_engineer.create_validation_loop(
+            implementation_requirements=feature_request,
+            success_criteria=[
+                "Feature implements all specified requirements",
+                "Code follows existing patterns and conventions",
+                "Implementation includes comprehensive error handling",
+                "All tests pass and coverage meets standards",
+                "Integration with existing systems is seamless"
+            ]
+        )
+        
+        implementation_blueprint = self.context_engineer.create_implementation_blueprint(
+            feature_request=feature_request,
+            context_analysis=codebase_analysis
+        )
+        
+        # Generate PRP for complete context
+        prp = self.context_engineer.generate_prp(
+            feature_request=feature_request,
+            context_analysis=codebase_analysis,
+            documentation_links=[
+                "https://docs.praisonai.com/",
+                "https://pydantic-docs.helpmanual.io/",
+                "https://fastapi.tiangolo.com/"
+            ]
+        )
+        
+        print(f"✅ Context Engineering Analysis Complete:")
+        print(f"   • Codebase analysis: {len(str(codebase_analysis))} chars")
+        print(f"   • Context document: {len(context_document)} chars")
+        print(f"   • Validation framework: {len(validation_framework['validation_steps'])} steps")
+        print(f"   • Implementation blueprint: {len(implementation_blueprint['implementation_steps'])} steps")
+        print(f"   • PRP generated: {len(prp)} chars")
+        
+        # Store context data for subsequent phases
+        self.context_data = {
+            "codebase_analysis": codebase_analysis,
+            "context_document": context_document,
+            "validation_framework": validation_framework,
+            "implementation_blueprint": implementation_blueprint,
+            "prp": prp
+        }
+        
+        # Phase 3: Architecture Design with Context
+        print("\n🏗️ Phase 3: Architecture Design with Context")
+        print("-" * 50)
+        
+        architecture_task = Task(
+            name="architecture_design",
+            description=f"""
+            Design system architecture for: '{feature_request}'
+            
+            Use the comprehensive context provided:
+            {context_document}
+            
+            Implementation Blueprint:
+            {implementation_blueprint}
+            
+            Design architecture that:
+            - Follows identified codebase patterns
+            - Integrates with existing systems
+            - Meets all technical requirements
+            - Is scalable and maintainable
+            """,
+            expected_output="Detailed system architecture design with component specifications",
+            agent=self.architect,
+            context=[requirements_task]
+        )
+        
+        # Phase 4: Implementation with Context-Enhanced Guidance
+        print("\n💻 Phase 4: Implementation with Context")
+        print("-" * 50)
+        
+        # Enhance the implementation prompt with context
+        enhanced_prompt = self.context_engineer.enhance_prompt_with_context(
+            base_prompt=f"Implement {feature_request}",
+            context_data=codebase_analysis
+        )
+        
+        implementation_task = Task(
+            name="feature_implementation",
+            description=f"""
+            Implement the feature using context-enhanced guidance:
+            
+            {enhanced_prompt}
+            
+            Product Requirements Prompt (PRP):
+            {prp}
+            
+            Architecture Design: Reference the architecture task output
+            
+            Implementation must:
+            - Follow the implementation blueprint exactly
+            - Use patterns identified in codebase analysis
+            - Meet all requirements from Phase 1
+            - Include comprehensive error handling
+            """,
+            expected_output="Complete feature implementation with code and documentation",
+            agent=self.developer,
+            context=[requirements_task, architecture_task]
+        )
+        
+        # Phase 5: Quality Assurance with Context-Generated Criteria
+        print("\n🔍 Phase 5: Quality Assurance with Context")
+        print("-" * 50)
+        
+        qa_task = Task(
+            name="quality_validation",
+            description=f"""
+            Validate the implementation using context-generated criteria:
+            
+            Validation Framework:
+            {validation_framework}
+            
+            Verify that implementation:
+            - Meets all success criteria defined in validation framework
+            - Follows codebase patterns and conventions
+            - Integrates properly with existing systems
+            - Handles edge cases and error scenarios
+            - Meets performance and security requirements
+            
+            Use the validation steps provided to systematically check each criterion.
+            """,
+            expected_output="Comprehensive quality validation report with pass/fail status",
+            agent=self.qa_engineer,
+            context=[requirements_task, architecture_task, implementation_task]
+        )
+        
+        # Execute the complete workflow
+        print("\n⚙️ Executing Context Engineering Workflow")
+        print("-" * 50)
+        
+        agents_workflow = PraisonAIAgents(
+            agents=[
+                self.product_manager,
+                self.architect, 
+                self.developer,
+                self.qa_engineer
+            ],
+            tasks=[
+                requirements_task,
+                architecture_task,
+                implementation_task,
+                qa_task
+            ],
+            process="sequential",
+            verbose=True
+        )
+        
+        # Execute workflow
+        workflow_results = agents_workflow.start()
+        
+        # Compile complete results
+        complete_results = {
+            "feature_request": feature_request,
+            "context_engineering": self.context_data,
+            "workflow_results": workflow_results,
+            "methodology": "Context Engineering - 10x better than prompt engineering"
+        }
+        
+        return complete_results
+
+def demonstrate_context_engineering_benefits():
+    """
+    Demonstrate the benefits of Context Engineering methodology.
+    """
+    print("\n📊 Context Engineering vs Traditional Approaches")
+    print("=" * 60)
+    
+    # Traditional approach simulation
+    print("\n❌ Traditional AI Coding Approach:")
+    print("   1. Write basic prompt: 'Implement user authentication'")
+    print("   2. AI uses general knowledge to implement")
+    print("   3. Result often doesn't fit existing codebase patterns")
+    print("   4. Multiple iterations needed to fix integration issues")
+    print("   5. Success rate: ~30-40% first-try success")
+    
+    # Context Engineering approach
+    print("\n✅ Context Engineering Approach:")
+    print("   1. Analyze codebase patterns and architecture")
+    print("   2. Generate comprehensive context document")
+    print("   3. Create validation framework with success criteria")
+    print("   4. Enhance prompts with rich contextual information")
+    print("   5. Generate PRP (Product Requirements Prompt)")
+    print("   6. AI implements using complete context")
+    print("   7. Success rate: ~90%+ first-try success")
+    
+    print("\n📈 Context Engineering Advantages:")
+    print("   • 10x better than prompt engineering (context vs clever wording)")
+    print("   • 100x better than vibe coding (structured vs ad-hoc)")
+    print("   • Enables first-try implementation success")
+    print("   • Reduces development iteration cycles")
+    print("   • Ensures consistency with existing codebase")
+    print("   • Provides built-in quality validation")
+
+def run_example_workflow():
+    """Run an example Context Engineering workflow."""
+    
+    # Setup workflow with current project
+    project_path = str(project_root)
+    workflow = ContextEngineeringWorkflow(
+        project_path=project_path,
+        llm="gpt-4o-mini"
+    )
+    
+    # Example feature request
+    feature_request = """
+    Implement a real-time notification system that:
+    - Sends notifications via WebSocket connections
+    - Supports different notification types (info, warning, error)
+    - Persists notifications in database for offline users
+    - Includes user preference management for notification settings
+    - Provides REST API for notification management
+    """
+    
+    print("🎯 Running Example Context Engineering Workflow")
+    print("=" * 60)
+    
+    try:
+        # Execute the complete workflow
+        results = workflow.run_context_engineering_workflow(feature_request)
+        
+        print("\n🎉 Context Engineering Workflow Completed Successfully!")
+        print("=" * 60)
+        
+        print(f"\n📊 Workflow Summary:")
+        print(f"   • Feature: Real-time notification system")
+        print(f"   • Context generated: ✅ Complete")
+        print(f"   • Architecture designed: ✅ With context")
+        print(f"   • Implementation: ✅ Context-guided")
+        print(f"   • Quality validation: ✅ Context-criteria")
+        
+        print(f"\n🔧 Context Engineering Data:")
+        context_data = results["context_engineering"]
+        print(f"   • Codebase analysis: {len(str(context_data['codebase_analysis']))} chars")
+        print(f"   • Context document: {len(context_data['context_document'])} chars") 
+        print(f"   • Validation framework: {len(context_data['validation_framework']['validation_steps'])} steps")
+        print(f"   • Implementation blueprint: {len(context_data['implementation_blueprint']['implementation_steps'])} steps")
+        print(f"   • PRP: {len(context_data['prp'])} chars")
+        
+        return results
+        
+    except Exception as e:
+        print(f"\n❌ Error in workflow execution: {e}")
+        print("   Note: This is a demonstration - actual execution requires proper environment setup")
+        return None
+
+if __name__ == "__main__":
+    print("🚀 Advanced Context Engineering Workflow Example")
+    print("================================================")
+    
+    print("\n💡 This example demonstrates the complete Context Engineering methodology:")
+    print("   • Comprehensive codebase analysis")
+    print("   • Context document generation")
+    print("   • Validation framework creation")
+    print("   • Multi-agent workflow with context integration")
+    print("   • Quality assurance with context-generated criteria")
+    
+    # Show benefits comparison
+    demonstrate_context_engineering_benefits()
+    
+    # Run example workflow (demo mode)
+    print("\n🎭 Demo Mode: Context Engineering Workflow Structure")
+    print("(Note: Full execution requires complete environment setup)")
+    
+    project_path = str(project_root)
+    workflow = ContextEngineeringWorkflow(project_path, "gpt-4o-mini")
+    
+    print(f"\n✅ Workflow Setup Complete:")
+    print(f"   • Project path: {project_path}")
+    print(f"   • Agents configured: 5 (PM, Context Engineer, Architect, Developer, QA)")
+    print(f"   • Context Engineering agent: ✅ Ready")
+    print(f"   • Multi-agent workflow: ✅ Configured")
+    
+    print(f"\n🎯 Ready to execute Context Engineering workflow!")
+    print(f"   Use workflow.run_context_engineering_workflow(feature_request)")
+    print(f"   to execute the complete methodology.")
+    
+    print(f"\n📚 Key Context Engineering Concepts Demonstrated:")
+    print(f"   • Pattern extraction from existing codebase")
+    print(f"   • Comprehensive context document generation")
+    print(f"   • Validation loop creation with success criteria")
+    print(f"   • PRP (Product Requirements Prompt) generation")
+    print(f"   • Context-enhanced prompt engineering")
+    print(f"   • Multi-agent workflow integration")
+    
+    print(f"\n🎉 Context Engineering: 10x better than prompt engineering, 100x better than vibe coding!")

examples/python/mongodb/llms.md

@@ -0,0 +1,20 @@
+# PraisonAI Documentation
+
+## Docs
+
+- [AI Agents](https://docs.praison.ai/docs/agents/agents.md): Overview of all available PraisonAI agents and their capabilities
+- [Data Analyst Agent](https://docs.praison.ai/docs/agents/data-analyst.md): Learn how to create AI agents for data analysis and insights generation.
+- [Finance Agent](https://docs.praison.ai/docs/agents/finance.md): Learn how to create AI agents for financial analysis and investment recommendations.
+- [Image Analysis Agent](https://docs.praison.ai/docs/agents/image.md): Learn how to create AI agents for image analysis and visual content understanding.
+- [Image to Text Agent](https://docs.praison.ai/docs/agents/image-to-text.md): Learn how to create AI agents for converting images to textual descriptions and extracting text from images.
+- [Markdown Agent](https://docs.praison.ai/docs/agents/markdown.md): Learn how to create AI agents for generating and formatting content in Markdown.
+- [Planning Agent](https://docs.praison.ai/docs/agents/planning.md): Learn how to create AI agents for trip planning and itinerary generation.
+- [Programming Agent](https://docs.praison.ai/docs/agents/programming.md): Learn how to create AI agents for code development, analysis, and execution.
+- [Recommendation Agent](https://docs.praison.ai/docs/agents/recommendation.md): Learn how to create AI agents for personalized recommendations across various domains.
+- [Research Agent](https://docs.praison.ai/docs/agents/research.md): Learn how to create AI agents for conducting comprehensive research and analysis.
+- [Shopping Agent](https://docs.praison.ai/docs/agents/shopping.md): Learn how to create AI agents for price comparison and shopping assistance.
+- [Single Agent](https://docs.praison.ai/docs/agents/single.md): Learn how to create a basic single-purpose AI agent for simple tasks.
+- [Video Agent](https://docs.praison.ai/docs/agents/video.md): Learn how to create AI agents for video analysis and content understanding.
+- [Web Search Agent](https://docs.praison.ai/docs/agents/websearch.md): Learn how to create AI agents for intelligent web searching and information gathering.
+- [Wikipedia Agent](https://docs.praison.ai/docs/agents/wikipedia.md): Learn how to create AI agents for searching and extracting information from Wikipedia.
+- [Agent Module](https://docs.praison.ai/docs/api/praisonaiagents/agent/agent.md): Documentation for the praisonaiagents.agent.agent module

examples/python/mongodb/mongodb_comprehensive_example.py

@@ -82,7 +82,6 @@ def main():
         backstory="""You are a knowledge management specialist who excels at 
         organizing, categorizing, and retrieving information from the knowledge base. 
         You ensure that knowledge is properly stored, indexed, and accessible.""",
-        knowledge=True,
         knowledge_config=mongodb_knowledge_config,
         memory=True,
         verbose=True,
@@ -111,7 +110,6 @@ def main():
         backstory="""You are a customer service representative who uses the 
         knowledge base and customer data to provide excellent support. You can 
         access customer history, product information, and troubleshooting guides.""",
-        knowledge=True,
         knowledge_config=mongodb_knowledge_config,
         tools=[mongodb_tools],
         memory=True,
@@ -208,10 +206,18 @@ def main():
         print("📊 Comprehensive Business System Results:")
         print("=" * 60)
         
-        for i, result in enumerate(results, 1):
-            print(f"\n{i}. Task Result:")
-            print(f"   Output: {result.raw[:200]}...")
-            print(f"   Agent: {result.agent}")
+        # Handle results structure properly
+        if isinstance(results, (list, tuple)):
+            for i, result in enumerate(results, 1):
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'raw') and hasattr(result, 'agent'):
+                    print(f"   Output: {result.raw[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Output: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
         
         print("\n" + "=" * 60)
         print("💾 Comprehensive MongoDB Integration Complete!")
@@ -222,10 +228,16 @@ def main():
         print("-" * 40)
         
         # Access different components
-        memory_system = business_system.memory
+        # Note: Direct memory access not available through business_system.memory
+        print("📋 Memory integration enabled through memory_config...")
+        print("Memory operations are handled internally by the agents")
+        
+        # Access memory system directly
+        from praisonaiagents.memory import Memory
+        memory_system = Memory(config=mongodb_memory_config)
         
         # Search business memories
-        print("📋 Searching business memories...")
+        print("\n📋 Searching business memories...")
         business_memories = memory_system.search_long_term("business analysis", limit=3)
         print(f"Found {len(business_memories)} business-related memories")
         

examples/python/mongodb/mongodb_knowledge_example.py

@@ -55,8 +55,8 @@ def main():
         retrieve information from a comprehensive MongoDB knowledge base. You excel 
         at finding relevant information, synthesizing knowledge from multiple sources, 
         and providing accurate, context-aware responses.""",
-        knowledge=True,
         knowledge_config=mongodb_knowledge_config,
+        knowledge=[os.path.join(os.path.dirname(__file__), "llms.md")],
         memory=True,
         verbose=True,
         llm="gpt-4o-mini"
@@ -139,10 +139,18 @@ def main():
         print("📊 Knowledge Management System Results:")
         print("=" * 60)
         
-        for i, result in enumerate(results, 1):
-            print(f"\n{i}. Task Result:")
-            print(f"   Output: {result.raw[:200]}...")
-            print(f"   Agent: {result.agent}")
+        # Handle results structure properly
+        if isinstance(results, (list, tuple)):
+            for i, result in enumerate(results, 1):
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'raw') and hasattr(result, 'agent'):
+                    print(f"   Output: {result.raw[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Output: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
         
         print("\n" + "=" * 60)
         print("💾 MongoDB Knowledge Integration Complete!")

examples/python/mongodb/mongodb_memory_example.py

@@ -107,10 +107,18 @@ def main():
         print("📊 Research System Results:")
         print("=" * 60)
         
-        for i, result in enumerate(results, 1):
-            print(f"\n{i}. Task Result:")
-            print(f"   Output: {result.raw[:200]}...")
-            print(f"   Agent: {result.agent}")
+        # Handle results structure properly
+        if isinstance(results, (list, tuple)):
+            for i, result in enumerate(results, 1):
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'agent'):
+                    print(f"   Output: {str(result)[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Output: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
             
         print("\n" + "=" * 60)
         print("💾 MongoDB Memory Integration Complete!")
@@ -120,20 +128,36 @@ def main():
         print("\n🔍 Demonstrating Memory Retrieval:")
         print("-" * 40)
         
-        # Access the memory system directly
-        memory_system = research_system.memory
-        
-        # Search for AI-related memories
-        ai_memories = memory_system.search_long_term("AI machine learning", limit=3)
-        print(f"Found {len(ai_memories)} AI-related memories:")
-        for memory in ai_memories:
-            print(f"  - {memory.get('text', '')[:100]}...")
-        
-        # Search for MongoDB-related memories
-        mongo_memories = memory_system.search_long_term("MongoDB vector search", limit=3)
-        print(f"\nFound {len(mongo_memories)} MongoDB-related memories:")
-        for memory in mongo_memories:
-            print(f"  - {memory.get('text', '')[:100]}...")
+        # Note: Direct memory access not available through research_system.memory
+        # Instead, use Memory class directly for verification
+        try:
+            from praisonaiagents.memory import Memory
+            
+            # Create Memory instance with MongoDB config for verification
+            memory_system = Memory(mongodb_memory_config)
+            
+            # Search for AI-related memories
+            ai_memories = memory_system.search_long_term("AI machine learning", limit=3)
+            print(f"Found {len(ai_memories)} AI-related memories:")
+            for memory in ai_memories:
+                if hasattr(memory, 'get'):
+                    print(f"  - {memory.get('text', '')[:100]}...")
+                else:
+                    print(f"  - {str(memory)[:100]}...")
+            
+            # Search for MongoDB-related memories
+            mongo_memories = memory_system.search_long_term("MongoDB vector search", limit=3)
+            print(f"\nFound {len(mongo_memories)} MongoDB-related memories:")
+            for memory in mongo_memories:
+                if hasattr(memory, 'get'):
+                    print(f"  - {memory.get('text', '')[:100]}...")
+                else:
+                    print(f"  - {str(memory)[:100]}...")
+                    
+        except ImportError:
+            print("Memory features not available - install with: pip install 'praisonaiagents[memory]'")
+        except Exception as mem_error:
+            print(f"Memory verification error: {mem_error}")
         
         print("\n✅ MongoDB Memory Example Completed Successfully!")
         

examples/python/mongodb/mongodb_tools_example.py

@@ -121,16 +121,26 @@ def main():
     
     # Execute the MongoDB operations pipeline
     try:
-        results = mongodb_system.start()
+        results = mongodb_system.start(return_dict=True)
         
         print("\n" + "=" * 60)
         print("📊 MongoDB Tools System Results:")
         print("=" * 60)
+        print(results)
         
-        for i, result in enumerate(results, 1):
-            print(f"\n{i}. Task Result:")
-            print(f"   Output: {result.raw[:200]}...")
-            print(f"   Agent: {result.agent}")
+        # Handle results structure properly
+        if isinstance(results, dict) and 'task_results' in results:
+            task_results = results['task_results']
+            for i, result in task_results.items():
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'raw') and hasattr(result, 'agent'):
+                    print(f"   Output: {result.raw[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Result: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
         
         print("\n" + "=" * 60)
         print("💾 MongoDB Tools Integration Complete!")

src/praisonai-agents/context_basic.py

@@ -0,0 +1,3 @@
+from praisonaiagents import ContextAgent
+agent = ContextAgent(llm="gpt-4o-mini", auto_analyze=False)
+prp = agent.start("https://github.com/MervinPraison/PraisonAI/ Need to add Authentication")

src/praisonai-agents/llms.md

@@ -0,0 +1,20 @@
+# PraisonAI Documentation
+
+## Docs
+
+- [AI Agents](https://docs.praison.ai/docs/agents/agents.md): Overview of all available PraisonAI agents and their capabilities
+- [Data Analyst Agent](https://docs.praison.ai/docs/agents/data-analyst.md): Learn how to create AI agents for data analysis and insights generation.
+- [Finance Agent](https://docs.praison.ai/docs/agents/finance.md): Learn how to create AI agents for financial analysis and investment recommendations.
+- [Image Analysis Agent](https://docs.praison.ai/docs/agents/image.md): Learn how to create AI agents for image analysis and visual content understanding.
+- [Image to Text Agent](https://docs.praison.ai/docs/agents/image-to-text.md): Learn how to create AI agents for converting images to textual descriptions and extracting text from images.
+- [Markdown Agent](https://docs.praison.ai/docs/agents/markdown.md): Learn how to create AI agents for generating and formatting content in Markdown.
+- [Planning Agent](https://docs.praison.ai/docs/agents/planning.md): Learn how to create AI agents for trip planning and itinerary generation.
+- [Programming Agent](https://docs.praison.ai/docs/agents/programming.md): Learn how to create AI agents for code development, analysis, and execution.
+- [Recommendation Agent](https://docs.praison.ai/docs/agents/recommendation.md): Learn how to create AI agents for personalized recommendations across various domains.
+- [Research Agent](https://docs.praison.ai/docs/agents/research.md): Learn how to create AI agents for conducting comprehensive research and analysis.
+- [Shopping Agent](https://docs.praison.ai/docs/agents/shopping.md): Learn how to create AI agents for price comparison and shopping assistance.
+- [Single Agent](https://docs.praison.ai/docs/agents/single.md): Learn how to create a basic single-purpose AI agent for simple tasks.
+- [Video Agent](https://docs.praison.ai/docs/agents/video.md): Learn how to create AI agents for video analysis and content understanding.
+- [Web Search Agent](https://docs.praison.ai/docs/agents/websearch.md): Learn how to create AI agents for intelligent web searching and information gathering.
+- [Wikipedia Agent](https://docs.praison.ai/docs/agents/wikipedia.md): Learn how to create AI agents for searching and extracting information from Wikipedia.
+- [Agent Module](https://docs.praison.ai/docs/api/praisonaiagents/agent/agent.md): Documentation for the praisonaiagents.agent.agent module

src/praisonai-agents/mongodb_comprehensive_example.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+Comprehensive MongoDB Integration Example for PraisonAI Agents
+
+This example demonstrates a complete MongoDB integration with PraisonAI agents,
+combining memory, knowledge, and tools for a comprehensive data management system.
+
+Prerequisites:
+- Install MongoDB dependencies: pip install 'praisonaiagents[mongodb]'
+- MongoDB server running (local or Atlas)
+- OpenAI API key for embeddings
+
+Features demonstrated:
+- MongoDB as memory provider
+- MongoDB as knowledge store
+- MongoDB tools for data operations
+- Vector search capabilities
+- Multi-agent coordination with MongoDB
+- Real-world business scenario simulation
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import mongodb_tools
+
+# Ensure OpenAI API key is set
+if not os.environ.get("OPENAI_API_KEY"):
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+def main():
+    # MongoDB configuration for different components
+    mongodb_memory_config = {
+        "provider": "mongodb",
+        "config": {
+            "connection_string": "mongodb://localhost:27017/",  # Replace with your connection string
+            "database": "praisonai_comprehensive",
+            "use_vector_search": True,
+            "max_pool_size": 50
+        }
+    }
+    
+    mongodb_knowledge_config = {
+        "vector_store": {
+            "provider": "mongodb",
+            "config": {
+                "connection_string": "mongodb://localhost:27017/",
+                "database": "praisonai_comprehensive",
+                "collection": "knowledge_base",
+                "use_vector_search": True
+            }
+        },
+        "embedder": {
+            "provider": "openai",
+            "config": {
+                "model": "text-embedding-3-small",
+                "api_key": os.getenv("OPENAI_API_KEY")
+            }
+        }
+    }
+    
+    # Create specialized agents for different business functions
+    
+    # 1. Data Manager Agent - handles data operations
+    data_manager = Agent(
+        name="Data Manager",
+        role="Senior Data Operations Manager",
+        goal="Manage and organize all data operations using MongoDB",
+        backstory="""You are an expert data operations manager who specializes in 
+        MongoDB database management. You handle data ingestion, organization, 
+        indexing, and ensure data quality and accessibility across the organization.""",
+        tools=[mongodb_tools],
+        memory=True,
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # 2. Knowledge Curator Agent - manages knowledge base
+    knowledge_curator = Agent(
+        name="Knowledge Curator",
+        role="Knowledge Management Specialist",
+        goal="Curate and maintain organizational knowledge using MongoDB",
+        backstory="""You are a knowledge management specialist who excels at 
+        organizing, categorizing, and retrieving information from the knowledge base. 
+        You ensure that knowledge is properly stored, indexed, and accessible.""",
+        knowledge_config=mongodb_knowledge_config,
+        memory=True,
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # 3. Business Analyst Agent - analyzes data and provides insights
+    business_analyst = Agent(
+        name="Business Analyst",
+        role="Senior Business Intelligence Analyst",
+        goal="Analyze business data and provide actionable insights",
+        backstory="""You are a senior business analyst who specializes in extracting 
+        insights from data stored in MongoDB. You create reports, identify trends, 
+        and provide strategic recommendations based on data analysis.""",
+        tools=[mongodb_tools],
+        memory=True,
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # 4. Customer Service Agent - handles customer interactions
+    customer_service = Agent(
+        name="Customer Service Agent",
+        role="Customer Service Representative",
+        goal="Provide excellent customer service using stored knowledge and data",
+        backstory="""You are a customer service representative who uses the 
+        knowledge base and customer data to provide excellent support. You can 
+        access customer history, product information, and troubleshooting guides.""",
+        knowledge_config=mongodb_knowledge_config,
+        tools=[mongodb_tools],
+        memory=True,
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create comprehensive business tasks
+    business_tasks = [
+        Task(
+            description="""Set up comprehensive business data infrastructure:
+            1. Create collections for customers, products, orders, and support tickets
+            2. Insert sample business data for an e-commerce platform
+            3. Set up appropriate indexes for performance optimization
+            4. Create vector indexes for product descriptions and customer support
+            5. Implement data validation and business rules
+            
+            Focus on creating a realistic business data structure.
+            """,
+            expected_output="Complete business data infrastructure with sample data",
+            agent=data_manager
+        ),
+        Task(
+            description="""Build organizational knowledge base:
+            1. Store product documentation and specifications
+            2. Create customer service guidelines and FAQs
+            3. Add troubleshooting guides and best practices
+            4. Include company policies and procedures
+            5. Organize knowledge by categories and tags
+            
+            Ensure knowledge is searchable and well-organized.
+            """,
+            expected_output="Comprehensive knowledge base with categorized information",
+            agent=knowledge_curator
+        ),
+        Task(
+            description="""Perform business intelligence analysis:
+            1. Analyze customer purchase patterns and behavior
+            2. Calculate key business metrics (revenue, conversion rates, etc.)
+            3. Identify top-selling products and categories
+            4. Analyze customer support ticket trends
+            5. Generate insights for business optimization
+            
+            Use MongoDB aggregation and analytics capabilities.
+            """,
+            expected_output="Business intelligence report with actionable insights",
+            agent=business_analyst
+        ),
+        Task(
+            description="""Handle customer service scenarios:
+            1. Process customer inquiries using knowledge base
+            2. Look up customer order history and preferences
+            3. Provide product recommendations based on customer data
+            4. Access troubleshooting guides for technical issues
+            5. Update customer records and interaction history
+            
+            Demonstrate excellent customer service with data-driven support.
+            """,
+            expected_output="Customer service interactions with knowledge-based responses",
+            agent=customer_service
+        ),
+        Task(
+            description="""Generate comprehensive business report:
+            1. Combine insights from all data sources
+            2. Create executive summary with key findings
+            3. Provide recommendations for business improvement
+            4. Include data visualizations and metrics
+            5. Store report in knowledge base for future reference
+            
+            Create a comprehensive business intelligence report.
+            """,
+            expected_output="Executive business report with comprehensive insights",
+            agent=business_analyst
+        )
+    ]
+    
+    # Initialize the comprehensive business system
+    print("🚀 Starting Comprehensive MongoDB Business System...")
+    print("=" * 60)
+    
+    business_system = PraisonAIAgents(
+        agents=[data_manager, knowledge_curator, business_analyst, customer_service],
+        tasks=business_tasks,
+        memory=True,
+        memory_config=mongodb_memory_config,
+        verbose=True
+    )
+    
+    # Execute the comprehensive business pipeline
+    try:
+        results = business_system.start()
+        
+        print("\n" + "=" * 60)
+        print("📊 Comprehensive Business System Results:")
+        print("=" * 60)
+        
+        # Handle results structure properly
+        if isinstance(results, (list, tuple)):
+            for i, result in enumerate(results, 1):
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'raw') and hasattr(result, 'agent'):
+                    print(f"   Output: {result.raw[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Output: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
+        
+        print("\n" + "=" * 60)
+        print("💾 Comprehensive MongoDB Integration Complete!")
+        print("=" * 60)
+        
+        # Demonstrate system integration
+        print("\n🔍 Demonstrating System Integration:")
+        print("-" * 40)
+        
+        # Access different components
+        # Note: Direct memory access not available through business_system.memory
+        print("📋 Memory integration enabled through memory_config...")
+        print("Memory operations are handled internally by the agents")
+        
+        # Access memory system directly
+        from praisonaiagents.memory import Memory
+        memory_system = Memory(config=mongodb_memory_config)
+        
+        # Search business memories
+        print("\n📋 Searching business memories...")
+        business_memories = memory_system.search_long_term("business analysis", limit=3)
+        print(f"Found {len(business_memories)} business-related memories")
+        
+        # Access knowledge system
+        from praisonaiagents.knowledge import Knowledge
+        knowledge_system = Knowledge(config=mongodb_knowledge_config)
+        
+        # Search knowledge base
+        print("\n📚 Searching knowledge base...")
+        knowledge_results = knowledge_system.search("customer service", limit=3)
+        print(f"Found {len(knowledge_results)} knowledge entries")
+        
+        # Direct MongoDB operations
+        print("\n🔧 Direct MongoDB operations...")
+        mongo_client = mongodb_tools.connect_mongodb(
+            "mongodb://localhost:27017/",
+            "praisonai_comprehensive"
+        )
+        
+        # Get database statistics
+        stats = mongo_client.get_stats("customers")
+        print(f"Customer collection stats: {stats}")
+        
+        print("\n" + "=" * 60)
+        print("🎉 Comprehensive MongoDB Example Completed Successfully!")
+        print("=" * 60)
+        
+        print("\n📈 System Overview:")
+        print("- Memory System: MongoDB-based persistent memory")
+        print("- Knowledge Base: MongoDB vector search enabled")
+        print("- Tools Integration: Full MongoDB CRUD operations")
+        print("- Multi-Agent Coordination: Business workflow simulation")
+        print("- Vector Search: Semantic search capabilities")
+        print("- Data Analytics: Business intelligence insights")
+        
+    except Exception as e:
+        print(f"\n❌ Error during execution: {e}")
+        print("Please check your MongoDB connection and API keys.")
+
+if __name__ == "__main__":
+    print("Comprehensive MongoDB Integration Example")
+    print("=" * 50)
+    print("This example demonstrates complete MongoDB integration with PraisonAI")
+    print("Features:")
+    print("- MongoDB Memory Provider")
+    print("- MongoDB Knowledge Store")
+    print("- MongoDB Tools Integration")
+    print("- Vector Search Capabilities")
+    print("- Multi-Agent Business Simulation")
+    print("=" * 50)
+    print("Make sure you have:")
+    print("1. MongoDB server running (local or Atlas)")
+    print("2. OpenAI API key set in environment variables")
+    print("3. MongoDB dependencies installed: pip install 'praisonaiagents[mongodb]'")
+    print("=" * 50)
+    
+    main()

src/praisonai-agents/mongodb_knowledge_example.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+MongoDB Knowledge Example for PraisonAI Agents
+
+This example demonstrates how to use MongoDB as a knowledge store for PraisonAI agents.
+MongoDB can store and retrieve knowledge documents with vector search capabilities.
+
+Prerequisites:
+- Install MongoDB dependencies: pip install 'praisonaiagents[mongodb]'
+- MongoDB server running (local or Atlas)
+- OpenAI API key for embeddings
+
+Features demonstrated:
+- MongoDB as knowledge vector store
+- Document processing and storage
+- Vector search for knowledge retrieval
+- Knowledge-based agent interactions
+- File processing with MongoDB storage
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Ensure OpenAI API key is set
+if not os.environ.get("OPENAI_API_KEY"):
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+def main():
+    # MongoDB knowledge configuration
+    mongodb_knowledge_config = {
+        "vector_store": {
+            "provider": "mongodb",
+            "config": {
+                "connection_string": "mongodb://localhost:27017/",  # Replace with your MongoDB connection string
+                "database": "praisonai_knowledge",
+                "collection": "knowledge_base",
+                "use_vector_search": True  # Enable Atlas Vector Search
+            }
+        },
+        "embedder": {
+            "provider": "openai",
+            "config": {
+                "model": "text-embedding-3-small",
+                "api_key": os.getenv("OPENAI_API_KEY")
+            }
+        }
+    }
+    
+    # Create a knowledge agent with MongoDB knowledge store
+    knowledge_agent = Agent(
+        name="MongoDB Knowledge Agent",
+        role="Knowledge Specialist",
+        goal="Provide accurate information from MongoDB knowledge base",
+        backstory="""You are an expert knowledge specialist who can access and 
+        retrieve information from a comprehensive MongoDB knowledge base. You excel 
+        at finding relevant information, synthesizing knowledge from multiple sources, 
+        and providing accurate, context-aware responses.""",
+        knowledge_config=mongodb_knowledge_config,
+        knowledge=[os.path.join(os.path.dirname(__file__), "llms.md")],
+        memory=True,
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create a research assistant agent
+    research_agent = Agent(
+        name="Research Assistant",
+        role="Research Assistant",
+        goal="Gather information and store it in the knowledge base",
+        backstory="""You are a research assistant who specializes in gathering 
+        information from various sources and organizing it for storage in the 
+        knowledge base. You ensure information is accurate, well-structured, 
+        and properly categorized.""",
+        memory=True,
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create tasks for knowledge management
+    knowledge_tasks = [
+        Task(
+            description="""Research and store information about MongoDB Atlas Vector Search:
+            1. Gather comprehensive information about MongoDB Atlas Vector Search
+            2. Include technical specifications, use cases, and best practices
+            3. Store the information in the MongoDB knowledge base
+            4. Organize information by categories (features, performance, integration)
+            """,
+            expected_output="MongoDB Atlas Vector Search information stored in knowledge base",
+            agent=research_agent
+        ),
+        Task(
+            description="""Research and store information about AI agent frameworks:
+            1. Research popular AI agent frameworks (LangChain, AutoGen, etc.)
+            2. Compare their features, capabilities, and use cases
+            3. Store comparative analysis in the knowledge base
+            4. Include code examples and best practices
+            """,
+            expected_output="AI agent framework comparison stored in knowledge base",
+            agent=research_agent
+        ),
+        Task(
+            description="""Query the knowledge base for MongoDB information:
+            1. Search for information about MongoDB Atlas Vector Search
+            2. Extract key features and capabilities
+            3. Provide a comprehensive summary
+            4. Include technical recommendations
+            """,
+            expected_output="Comprehensive MongoDB Atlas Vector Search summary from knowledge base",
+            agent=knowledge_agent
+        ),
+        Task(
+            description="""Query the knowledge base for AI agent framework information:
+            1. Search for information about AI agent frameworks
+            2. Compare different frameworks based on stored knowledge
+            3. Provide recommendations for different use cases
+            4. Include best practices and examples
+            """,
+            expected_output="AI agent framework comparison and recommendations from knowledge base",
+            agent=knowledge_agent
+        )
+    ]
+    
+    # Initialize the multi-agent system with MongoDB knowledge
+    print("🚀 Starting MongoDB Knowledge Management System...")
+    print("=" * 60)
+    
+    knowledge_system = PraisonAIAgents(
+        agents=[research_agent, knowledge_agent],
+        tasks=knowledge_tasks,
+        memory=True,
+        verbose=True
+    )
+    
+    # Execute the knowledge management pipeline
+    try:
+        results = knowledge_system.start()
+        
+        print("\n" + "=" * 60)
+        print("📊 Knowledge Management System Results:")
+        print("=" * 60)
+        
+        # Handle results structure properly
+        if isinstance(results, (list, tuple)):
+            for i, result in enumerate(results, 1):
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'raw') and hasattr(result, 'agent'):
+                    print(f"   Output: {result.raw[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Output: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
+        
+        print("\n" + "=" * 60)
+        print("💾 MongoDB Knowledge Integration Complete!")
+        print("=" * 60)
+        
+        # Demonstrate direct knowledge access
+        print("\n🔍 Demonstrating Direct Knowledge Access:")
+        print("-" * 40)
+        
+        # Access knowledge system directly
+        from praisonaiagents.knowledge import Knowledge
+        
+        knowledge_system = Knowledge(config=mongodb_knowledge_config)
+        
+        # Store a sample document
+        sample_doc = """
+        MongoDB is a document-oriented database that provides high performance, 
+        high availability, and easy scalability. It works on the concept of 
+        collections and documents, using a flexible, JSON-like document model.
+        """
+        
+        print("📄 Storing sample document...")
+        knowledge_system.store(sample_doc, metadata={"category": "database", "type": "overview"})
+        
+        # Search for stored knowledge
+        print("\n🔍 Searching knowledge base...")
+        results = knowledge_system.search("MongoDB document database", limit=3)
+        
+        print(f"Found {len(results)} knowledge entries:")
+        for result in results:
+            print(f"  - {result.get('memory', '')[:100]}...")
+            print(f"    Score: {result.get('score', 'N/A')}")
+        
+        print("\n✅ MongoDB Knowledge Example Completed Successfully!")
+        
+    except Exception as e:
+        print(f"\n❌ Error during execution: {e}")
+        print("Please check your MongoDB connection and API keys.")
+
+if __name__ == "__main__":
+    print("MongoDB Knowledge Example for PraisonAI Agents")
+    print("=" * 50)
+    print("This example demonstrates MongoDB integration for knowledge management")
+    print("Make sure you have:")
+    print("1. MongoDB server running (local or Atlas)")
+    print("2. OpenAI API key set in environment variables")
+    print("3. MongoDB dependencies installed: pip install 'praisonaiagents[mongodb]'")
+    print("=" * 50)
+    
+    main()

src/praisonai-agents/mongodb_memory_example.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+MongoDB Memory Example for PraisonAI Agents
+
+This example demonstrates how to use MongoDB as a memory provider for PraisonAI agents.
+MongoDB can be used as both a key-value store and a vector database for memory operations.
+
+Prerequisites:
+- Install MongoDB dependencies: pip install 'praisonaiagents[mongodb]'
+- MongoDB server running (local or Atlas)
+- OpenAI API key for embeddings
+
+Features demonstrated:
+- MongoDB as memory provider
+- Vector search with Atlas Vector Search
+- Quality scoring and filtering
+- User-specific memory storage
+- Persistent memory across sessions
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Ensure OpenAI API key is set
+if not os.environ.get("OPENAI_API_KEY"):
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+def main():
+    # MongoDB memory configuration
+    mongodb_memory_config = {
+        "provider": "mongodb",
+        "config": {
+            "connection_string": "mongodb://localhost:27017/",  # Replace with your MongoDB connection string
+            "database": "praisonai_memory",
+            "use_vector_search": True,  # Enable Atlas Vector Search (requires MongoDB Atlas)
+            "max_pool_size": 50,
+            "min_pool_size": 10,
+            "server_selection_timeout": 5000
+        }
+    }
+    
+    # Create a research agent with MongoDB memory
+    research_agent = Agent(
+        name="MongoDB Research Agent",
+        role="Senior Research Specialist",
+        goal="Research topics and maintain persistent memory using MongoDB",
+        backstory="""You are an expert researcher who specializes in collecting, 
+        analyzing, and storing information using advanced MongoDB-based memory systems. 
+        You excel at maintaining context across multiple research sessions and can 
+        retrieve relevant information from your persistent memory store.""",
+        memory=True,
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create research tasks
+    research_tasks = [
+        Task(
+            description="""Research the latest developments in AI/ML for 2024:
+            1. Identify major AI breakthroughs and trends
+            2. Analyze the impact on various industries
+            3. Store key findings in MongoDB memory with quality scores
+            4. Identify emerging technologies and their potential applications
+            """,
+            expected_output="Comprehensive AI/ML research report with key findings stored in MongoDB",
+            agent=research_agent
+        ),
+        Task(
+            description="""Research MongoDB Atlas Vector Search capabilities:
+            1. Explore vector search features and use cases
+            2. Compare with other vector databases
+            3. Analyze performance and scalability
+            4. Store technical insights in MongoDB memory
+            """,
+            expected_output="Technical analysis of MongoDB Atlas Vector Search with stored insights",
+            agent=research_agent
+        ),
+        Task(
+            description="""Research AI agent frameworks and tools:
+            1. Compare popular AI agent frameworks
+            2. Analyze their strengths and weaknesses
+            3. Identify best practices for agent development
+            4. Store comparative analysis in MongoDB memory
+            """,
+            expected_output="Comparative analysis of AI agent frameworks with stored insights",
+            agent=research_agent
+        )
+    ]
+    
+    # Initialize the multi-agent system with MongoDB memory
+    print("🚀 Starting MongoDB Memory Research System...")
+    print("=" * 60)
+    
+    research_system = PraisonAIAgents(
+        agents=[research_agent],
+        tasks=research_tasks,
+        memory=True,
+        memory_config=mongodb_memory_config,
+        verbose=True
+    )
+    
+    # Execute the research pipeline
+    try:
+        results = research_system.start()
+        
+        print("\n" + "=" * 60)
+        print("📊 Research System Results:")
+        print("=" * 60)
+        
+        # Handle results structure properly
+        if isinstance(results, (list, tuple)):
+            for i, result in enumerate(results, 1):
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'agent'):
+                    print(f"   Output: {str(result)[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Output: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
+            
+        print("\n" + "=" * 60)
+        print("💾 MongoDB Memory Integration Complete!")
+        print("=" * 60)
+        
+        # Demonstrate memory retrieval
+        print("\n🔍 Demonstrating Memory Retrieval:")
+        print("-" * 40)
+        
+        # Note: Direct memory access not available through research_system.memory
+        # Instead, use Memory class directly for verification
+        try:
+            from praisonaiagents.memory import Memory
+            
+            # Create Memory instance with MongoDB config for verification
+            memory_system = Memory(mongodb_memory_config)
+            
+            # Search for AI-related memories
+            ai_memories = memory_system.search_long_term("AI machine learning", limit=3)
+            print(f"Found {len(ai_memories)} AI-related memories:")
+            for memory in ai_memories:
+                if hasattr(memory, 'get'):
+                    print(f"  - {memory.get('text', '')[:100]}...")
+                else:
+                    print(f"  - {str(memory)[:100]}...")
+            
+            # Search for MongoDB-related memories
+            mongo_memories = memory_system.search_long_term("MongoDB vector search", limit=3)
+            print(f"\nFound {len(mongo_memories)} MongoDB-related memories:")
+            for memory in mongo_memories:
+                if hasattr(memory, 'get'):
+                    print(f"  - {memory.get('text', '')[:100]}...")
+                else:
+                    print(f"  - {str(memory)[:100]}...")
+                    
+        except ImportError:
+            print("Memory features not available - install with: pip install 'praisonaiagents[memory]'")
+        except Exception as mem_error:
+            print(f"Memory verification error: {mem_error}")
+        
+        print("\n✅ MongoDB Memory Example Completed Successfully!")
+        
+    except Exception as e:
+        print(f"\n❌ Error during execution: {e}")
+        print("Please check your MongoDB connection and API keys.")
+
+if __name__ == "__main__":
+    print("MongoDB Memory Example for PraisonAI Agents")
+    print("=" * 50)
+    print("This example demonstrates MongoDB integration for persistent memory")
+    print("Make sure you have:")
+    print("1. MongoDB server running (local or Atlas)")
+    print("2. OpenAI API key set in environment variables")
+    print("3. MongoDB dependencies installed: pip install 'praisonaiagents[mongodb]'")
+    print("=" * 50)
+    
+    main()

src/praisonai-agents/mongodb_tools_example.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+MongoDB Tools Example for PraisonAI Agents
+
+This example demonstrates how to use MongoDB tools with PraisonAI agents.
+Agents can perform MongoDB operations like inserting, querying, and vector search.
+
+Prerequisites:
+- Install MongoDB dependencies: pip install 'praisonaiagents[mongodb]'
+- MongoDB server running (local or Atlas)
+- OpenAI API key for embeddings
+
+Features demonstrated:
+- MongoDB tools integration
+- Document CRUD operations
+- Vector search with embeddings
+- Data analysis with MongoDB
+- Agent-driven database operations
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import mongodb_tools
+
+# Ensure OpenAI API key is set
+if not os.environ.get("OPENAI_API_KEY"):
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+def main():
+    # Create a MongoDB Database Agent with MongoDB tools
+    db_agent = Agent(
+        name="MongoDB Database Agent",
+        role="Database Operations Specialist",
+        goal="Manage MongoDB operations and data analysis",
+        backstory="""You are an expert database administrator who specializes in 
+        MongoDB operations. You can perform complex database queries, manage 
+        collections, and analyze data patterns. You excel at using MongoDB tools 
+        for data management and retrieval.""",
+        tools=[mongodb_tools],
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create a Data Analysis Agent
+    analysis_agent = Agent(
+        name="Data Analysis Agent",
+        role="Data Analyst",
+        goal="Analyze data stored in MongoDB and provide insights",
+        backstory="""You are a data analyst who specializes in extracting insights 
+        from MongoDB databases. You can query data, perform aggregations, and 
+        identify patterns and trends in the stored information.""",
+        tools=[mongodb_tools],
+        verbose=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create tasks for MongoDB operations
+    mongodb_tasks = [
+        Task(
+            description="""Set up MongoDB collections and insert sample data:
+            1. Create a collection called 'products' for e-commerce data
+            2. Insert sample product documents with fields: name, price, category, description
+            3. Create a collection called 'users' for user data
+            4. Insert sample user documents with fields: name, email, age, preferences
+            5. Create appropriate indexes for better query performance
+            
+            Use the MongoDB tools to perform these operations.
+            """,
+            expected_output="MongoDB collections created with sample data and indexes",
+            agent=db_agent
+        ),
+        Task(
+            description="""Perform vector search operations:
+            1. Create a vector index for product descriptions
+            2. Store products with text embeddings for vector search
+            3. Demonstrate vector similarity search for product recommendations
+            4. Show how to find similar products based on description embeddings
+            
+            Use the MongoDB vector search tools for these operations.
+            """,
+            expected_output="Vector search implementation with product recommendations",
+            agent=db_agent
+        ),
+        Task(
+            description="""Query and analyze the stored data:
+            1. Find all products in a specific category
+            2. Calculate average price by category
+            3. Find users with specific preferences
+            4. Perform text search on product descriptions
+            5. Generate insights about the data patterns
+            
+            Use MongoDB query tools to perform these analyses.
+            """,
+            expected_output="Data analysis report with insights from MongoDB queries",
+            agent=analysis_agent
+        ),
+        Task(
+            description="""Demonstrate advanced MongoDB operations:
+            1. Update product prices based on specific criteria
+            2. Perform aggregation operations for statistical analysis
+            3. Create reports on user demographics and preferences
+            4. Implement data validation and error handling
+            5. Show MongoDB best practices for data management
+            
+            Use MongoDB tools for these advanced operations.
+            """,
+            expected_output="Advanced MongoDB operations report with best practices",
+            agent=db_agent
+        )
+    ]
+    
+    # Initialize the multi-agent system with MongoDB tools
+    print("🚀 Starting MongoDB Tools Demo System...")
+    print("=" * 60)
+    
+    mongodb_system = PraisonAIAgents(
+        agents=[db_agent, analysis_agent],
+        tasks=mongodb_tasks,
+        verbose=True
+    )
+    
+    # Execute the MongoDB operations pipeline
+    try:
+        results = mongodb_system.start(return_dict=True)
+        
+        print("\n" + "=" * 60)
+        print("📊 MongoDB Tools System Results:")
+        print("=" * 60)
+        print(results)
+        
+        # Handle results structure properly
+        if isinstance(results, dict) and 'task_results' in results:
+            task_results = results['task_results']
+            for i, result in task_results.items():
+                print(f"\n{i}. Task Result:")
+                if hasattr(result, 'raw') and hasattr(result, 'agent'):
+                    print(f"   Output: {result.raw[:200]}...")
+                    print(f"   Agent: {result.agent}")
+                else:
+                    print(f"   Result: {str(result)[:200]}...")
+        else:
+            print(f"\n1. Task Result:")
+            print(f"   Output: {str(results)[:200]}...")
+        
+        print("\n" + "=" * 60)
+        print("💾 MongoDB Tools Integration Complete!")
+        print("=" * 60)
+        
+        # Demonstrate direct MongoDB tools usage
+        print("\n🔍 Demonstrating Direct MongoDB Tools Usage:")
+        print("-" * 40)
+        
+        # Connect to MongoDB
+        mongo_client = mongodb_tools.connect_mongodb(
+            "mongodb://localhost:27017/",  # Replace with your connection string
+            "praisonai_tools_demo"
+        )
+        
+        # Insert a sample document
+        print("📄 Inserting sample document...")
+        result = mongo_client.insert_document(
+            "demo_collection",
+            {
+                "title": "MongoDB Tools Demo",
+                "description": "Demonstration of MongoDB tools with PraisonAI",
+                "category": "database",
+                "tags": ["mongodb", "praisonai", "tools", "demo"]
+            },
+            metadata={"created_by": "demo", "version": "1.0"}
+        )
+        print(f"   Result: {result}")
+        
+        # Query documents
+        print("\n🔍 Querying documents...")
+        documents = mongo_client.find_documents(
+            "demo_collection",
+            {"category": "database"},
+            limit=5
+        )
+        print(f"   Found {len(documents)} documents")
+        for doc in documents:
+            print(f"   - {doc.get('title', 'N/A')}: {doc.get('description', '')[:50]}...")
+        
+        # Get collection statistics
+        print("\n📈 Getting collection statistics...")
+        stats = mongo_client.get_stats("demo_collection")
+        print(f"   Collection stats: {stats}")
+        
+        print("\n✅ MongoDB Tools Example Completed Successfully!")
+        
+    except Exception as e:
+        print(f"\n❌ Error during execution: {e}")
+        print("Please check your MongoDB connection and API keys.")
+
+if __name__ == "__main__":
+    print("MongoDB Tools Example for PraisonAI Agents")
+    print("=" * 50)
+    print("This example demonstrates MongoDB tools integration")
+    print("Make sure you have:")
+    print("1. MongoDB server running (local or Atlas)")
+    print("2. OpenAI API key set in environment variables")
+    print("3. MongoDB dependencies installed: pip install 'praisonaiagents[mongodb]'")
+    print("=" * 50)
+    
+    main()

src/praisonai-agents/praisonaiagents/__init__.py

@@ -28,6 +28,7 @@ logging.getLogger("httpcore").setLevel(logging.WARNING)
 
 from .agent.agent import Agent
 from .agent.image_agent import ImageAgent
+from .agent.context_agent import ContextAgent, create_context_agent
 from .agents.agents import PraisonAIAgents
 from .task.task import Task
 from .tools.tools import Tools
@@ -108,6 +109,8 @@ if _telemetry_available:
 __all__ = [
     'Agent',
     'ImageAgent',
+    'ContextAgent',
+    'create_context_agent',
     'PraisonAIAgents',
     'Agents',
     'Tools',

src/praisonai-agents/praisonaiagents/agent/__init__.py

@@ -1,7 +1,8 @@
 """Agent module for AI agents"""
 from .agent import Agent
 from .image_agent import ImageAgent
+from .context_agent import ContextAgent, create_context_agent
 from .handoff import Handoff, handoff, handoff_filters, RECOMMENDED_PROMPT_PREFIX, prompt_with_handoff_instructions
 from .router_agent import RouterAgent
 
-__all__ = ['Agent', 'ImageAgent', 'Handoff', 'handoff', 'handoff_filters', 'RECOMMENDED_PROMPT_PREFIX', 'prompt_with_handoff_instructions', 'RouterAgent']
+__all__ = ['Agent', 'ImageAgent', 'ContextAgent', 'create_context_agent', 'Handoff', 'handoff', 'handoff_filters', 'RECOMMENDED_PROMPT_PREFIX', 'prompt_with_handoff_instructions', 'RouterAgent']

src/praisonai-agents/praisonaiagents/agents/agents.py

@@ -81,16 +81,19 @@ def process_task_context(context_item, verbose=0, user_id=None):
         task_name = context_item.name if context_item.name else context_item.description
         
         if context_item.result and task_status == TaskStatus.COMPLETED.value:
-            return f"Result of previous task {task_name}:\n{context_item.result.raw}"
+            # Log detailed result for debugging
+            logger.debug(f"Previous task '{task_name}' result: {context_item.result.raw}")
+            # Return actual result content without verbose label (essential for task chaining)
+            return context_item.result.raw
         elif task_status == TaskStatus.COMPLETED.value and not context_item.result:
-            return f"Previous task {task_name} completed but produced no result."
+            return ""  # No result to include
         else:
-            return f"Previous task {task_name} is not yet completed (status: {task_status or TaskStatus.UNKNOWN.value})."
-    elif isinstance(context_item, dict) and "vector_store" in context_item:
+            return ""  # Task not completed, no context to include
+    elif isinstance(context_item, dict) and ("vector_store" in context_item or "embedding_db_config" in context_item):
         from ..knowledge.knowledge import Knowledge
         try:
-            # Handle both string and dict configs
-            cfg = context_item["vector_store"]
+            # Handle both string and dict configs - support both vector_store and embedding_db_config keys for backward compatibility
+            cfg = context_item.get("vector_store") or context_item.get("embedding_db_config")
             if isinstance(cfg, str):
                 cfg = json.loads(cfg)
             
@@ -101,9 +104,19 @@ def process_task_context(context_item, verbose=0, user_id=None):
                 context_item.get("query", ""),  # Use query from context if available
                 user_id=user_id if user_id else None
             )
-            return f"[DB Context]: {str(db_results)}"
+            
+            # Log knowledge results for debugging (always available for troubleshooting)
+            logger.debug(f"Knowledge search results ({len(db_results)} items): {str(db_results)}")
+            
+            # Return actual content without verbose "[DB Context]:" prefix
+            return str(db_results)
         except Exception as e:
-            return f"[Vector DB Error]: {e}"
+            # Log error for debugging (always available for troubleshooting)
+            logger.debug(f"Vector DB Error: {e}")
+            
+            # Return empty string to avoid exposing error details in AI prompts
+            # Error details are preserved in debug logs for troubleshooting
+            return ""
     else:
         return str(context_item)  # Fallback for unknown types
 
@@ -148,7 +161,9 @@ class PraisonAIAgents:
         
         # Set logger level based on verbose
         if verbose >= 5:
-            logger.setLevel(logging.INFO)
+            logger.setLevel(logging.INFO)      # keep everything ≥INFO
+        elif verbose >= 3:
+            logger.setLevel(logging.DEBUG)     # surface DEBUG when user asks for it
         else:
             logger.setLevel(logging.WARNING)
             
@@ -312,7 +327,7 @@ Expected Output: {task.expected_output}.
             if self.verbose >= 3:
                 logger.info(f"Task {task_id} context items: {len(unique_contexts)}")
                 for i, ctx in enumerate(unique_contexts):
-                    logger.info(f"Context {i+1}: {ctx[:100]}...")
+                    logger.debug(f"Context {i+1}: {ctx[:100]}...")
             context_separator = '\n\n'
             task_prompt += f"""
 Context:
@@ -635,7 +650,7 @@ Expected Output: {task.expected_output}.
             if self.verbose >= 3:
                 logger.info(f"Task {task_id} context items: {len(unique_contexts)}")
                 for i, ctx in enumerate(unique_contexts):
-                    logger.info(f"Context {i+1}: {ctx[:100]}...")
+                    logger.debug(f"Context {i+1}: {ctx[:100]}...")
             context_separator = '\n\n'
             task_prompt += f"""
 Context:
@@ -648,7 +663,10 @@ Context:
             try:
                 memory_context = task.memory.build_context_for_task(task.description)
                 if memory_context:
-                    task_prompt += f"\n\nRelevant memory context:\n{memory_context}"
+                    # Log detailed memory context for debugging
+                    logger.debug(f"Memory context for task '{task.description}': {memory_context}")
+                    # Include actual memory content without verbose headers (essential for AI agent functionality)
+                    task_prompt += f"\n\n{memory_context}"
             except Exception as e:
                 logger.error(f"Error getting memory context: {e}")
 

src/praisonai-agents/praisonaiagents/knowledge/knowledge.py

@@ -714,7 +714,15 @@ class Knowledge:
                         memory_result = self.store(memory, user_id=user_id, agent_id=agent_id, 
                                                  run_id=run_id, metadata=metadata)
                         if memory_result:
-                            all_results.extend(memory_result.get('results', []))
+                            # Handle both dict and list formats for backward compatibility
+                            if isinstance(memory_result, dict):
+                                all_results.extend(memory_result.get('results', []))
+                            elif isinstance(memory_result, list):
+                                all_results.extend(memory_result)
+                            else:
+                                # Log warning for unexpected types but don't break
+                                import logging
+                                logging.warning(f"Unexpected memory_result type: {type(memory_result)}, skipping")
                         progress.advance(store_task)
 
             return {'results': all_results, 'relations': []}

src/praisonai-agents/praisonaiagents/memory/memory.py

@@ -10,9 +10,19 @@ from datetime import datetime
 # Disable litellm telemetry before any imports
 os.environ["LITELLM_TELEMETRY"] = "False"
 
-# Set up logger
+# Set up logger with custom TRACE level
 logger = logging.getLogger(__name__)
 
+# Add custom TRACE level (below DEBUG)
+TRACE_LEVEL = 5
+logging.addLevelName(TRACE_LEVEL, 'TRACE')
+
+def trace(self, message, *args, **kwargs):
+    if self.isEnabledFor(TRACE_LEVEL):
+        self._log(TRACE_LEVEL, message, args, **kwargs)
+
+logging.Logger.trace = trace
+
 try:
     import chromadb
     from chromadb.config import Settings as ChromaSettings
@@ -770,7 +780,7 @@ class Memory:
                     import litellm
                     
                     logger.info("Getting embeddings from LiteLLM...")
-                    logger.debug(f"Embedding input text: {text}")
+                    logger.trace(f"Embedding input text: {text}")
                     
                     response = litellm.embedding(
                         model=self.embedding_model,
@@ -778,7 +788,7 @@ class Memory:
                     )
                     embedding = response.data[0]["embedding"]
                     logger.info("Successfully got embeddings from LiteLLM")
-                    logger.debug(f"Received embedding of length: {len(embedding)}")
+                    logger.trace(f"Received embedding of length: {len(embedding)}")
                     
                 elif OPENAI_AVAILABLE:
                     # Fallback to OpenAI client
@@ -786,7 +796,7 @@ class Memory:
                     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
                     
                     logger.info("Getting embeddings from OpenAI...")
-                    logger.debug(f"Embedding input text: {text}")
+                    logger.trace(f"Embedding input text: {text}")
                     
                     response = client.embeddings.create(
                         input=text,
@@ -794,7 +804,7 @@ class Memory:
                     )
                     embedding = response.data[0].embedding
                     logger.info("Successfully got embeddings from OpenAI")
-                    logger.debug(f"Received embedding of length: {len(embedding)}")
+                    logger.trace(f"Received embedding of length: {len(embedding)}")
                 else:
                     logger.warning("Neither litellm nor openai available for embeddings")
                     return
@@ -1243,12 +1253,22 @@ class Memory:
         task_descr: str,
         user_id: Optional[str] = None,
         additional: str = "",
-        max_items: int = 3
+        max_items: int = 3,
+        include_in_output: Optional[bool] = None
     ) -> str:
         """
         Merges relevant short-term, long-term, entity, user memories
         into a single text block with deduplication and clean formatting.
+        
+        Args:
+            include_in_output: If None, memory content is only included when debug logging is enabled.
+                               If True, memory content is always included.
+                               If False, memory content is never included (only logged for debugging).
         """
+        # Determine whether to include memory content in output based on logging level
+        if include_in_output is None:
+            include_in_output = logging.getLogger().getEffectiveLevel() == logging.DEBUG
+        
         q = (task_descr + " " + additional).strip()
         lines = []
         seen_contents = set()  # Track unique contents
@@ -1306,16 +1326,20 @@ class Memory:
                     formatted_hits.append(formatted)
             
             if formatted_hits:
-                # Add section header
-                if lines:
-                    lines.append("")  # Space before new section
-                lines.append(title)
-                lines.append("=" * len(title))  # Underline the title
-                lines.append("")  # Space after title
+                # Log detailed memory content for debugging including section headers
+                brief_title = title.replace(" Context", "").replace("Memory ", "")
+                logger.debug(f"Memory section '{brief_title}' ({len(formatted_hits)} items): {formatted_hits}")
                 
-                # Add formatted content with bullet points
-                for content in formatted_hits:
-                    lines.append(f" • {content}")
+                # Only include memory content in output when specified (controlled by log level or explicit parameter)
+                if include_in_output:
+                    # Add only the actual memory content for AI agent use (no headers)
+                    if lines:
+                        lines.append("")  # Space before new section
+                    
+                    # Include actual memory content without verbose section headers
+                    for hit in formatted_hits:
+                        lines.append(f"• {hit}")
+                    lines.append("")  # Space after content
 
         # Add each section
         # First get all results

src/praisonai-agents/praisonaiagents/task/task.py

@@ -402,13 +402,14 @@ Expected Output: {self.expected_output}.
                     context_results.append(f"Input Content: {' '.join(str(x) for x in context_item)}")
                 elif hasattr(context_item, 'result'):  # Task object
                     if context_item.result:
-                        context_results.append(
-                            f"Result of previous task {context_item.name if context_item.name else context_item.description}:\n{context_item.result.raw}"
-                        )
+                        task_name = context_item.name if context_item.name else context_item.description
+                        # Log detailed result for debugging
+                        logger.debug(f"Previous task '{task_name}' result: {context_item.result.raw}")
+                        # Include actual result content without verbose labels (essential for task chaining)
+                        context_results.append(context_item.result.raw)
                     else:
-                        context_results.append(
-                            f"Previous task {context_item.name if context_item.name else context_item.description} has no result yet."
-                        )
+                        # Task has no result yet, don't include verbose status message
+                        pass
 
             # Join unique context results
             unique_contexts = list(dict.fromkeys(context_results))  # Remove duplicates

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.144"
+version = "0.0.145"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [

src/praisonai-agents/tests/test_context_agent.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""
+Test ContextAgent Implementation
+
+This test script validates the ContextAgent implementation for:
+- Import capability
+- Basic instantiation
+- Method availability
+- Backward compatibility
+- Integration with existing PraisonAI structure
+"""
+
+import sys
+from pathlib import Path
+
+# Add the src directory to Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+def test_imports():
+    """Test that ContextAgent can be imported correctly."""
+    print("🧪 Testing ContextAgent Imports...")
+    
+    try:
+        # Test importing from main package
+        from praisonaiagents import ContextAgent, create_context_agent
+        print("✅ Successfully imported ContextAgent and create_context_agent from main package")
+        
+        # Test importing from agent submodule
+        from praisonaiagents.agent import ContextAgent as AgentContextAgent
+        print("✅ Successfully imported ContextAgent from agent submodule")
+        
+        # Test importing from specific module
+        from praisonaiagents.agent.context_agent import ContextAgent as DirectContextAgent
+        print("✅ Successfully imported ContextAgent from direct module")
+        
+        return True
+        
+    except ImportError as e:
+        print(f"❌ Import failed: {e}")
+        return False
+
+def test_basic_instantiation():
+    """Test basic ContextAgent instantiation."""
+    print("\\n🧪 Testing ContextAgent Instantiation...")
+    
+    try:
+        from praisonaiagents import ContextAgent, create_context_agent
+        
+        # Test direct instantiation
+        context_agent = ContextAgent()
+        print("✅ Successfully created ContextAgent with default parameters")
+        
+        # Test with custom parameters
+        custom_agent = ContextAgent(
+            name="Test Context Engineer",
+            role="Test Role",
+            goal="Test Goal",
+            llm="gpt-4o-mini"
+        )
+        print("✅ Successfully created ContextAgent with custom parameters")
+        
+        # Test factory function
+        factory_agent = create_context_agent(llm="gpt-4o-mini")
+        print("✅ Successfully created ContextAgent using factory function")
+        
+        return True, [context_agent, custom_agent, factory_agent]
+        
+    except Exception as e:
+        print(f"❌ Instantiation failed: {e}")
+        return False, []
+
+def test_agent_inheritance():
+    """Test that ContextAgent properly inherits from Agent."""
+    print("\\n🧪 Testing Agent Inheritance...")
+    
+    try:
+        from praisonaiagents import ContextAgent, Agent
+        
+        context_agent = ContextAgent()
+        
+        # Test inheritance
+        assert isinstance(context_agent, Agent), "ContextAgent should inherit from Agent"
+        print("✅ ContextAgent properly inherits from Agent class")
+        
+        # Test that base Agent properties exist
+        assert hasattr(context_agent, 'name'), "Should have name attribute"
+        assert hasattr(context_agent, 'role'), "Should have role attribute"
+        assert hasattr(context_agent, 'goal'), "Should have goal attribute"
+        print("✅ ContextAgent has all required Agent attributes")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Inheritance test failed: {e}")
+        return False
+
+def test_context_engineering_methods():
+    """Test Context Engineering specific methods."""
+    print("\\n🧪 Testing Context Engineering Methods...")
+    
+    try:
+        from praisonaiagents import create_context_agent
+        
+        context_agent = create_context_agent()
+        
+        # Test that all Context Engineering methods exist
+        required_methods = [
+            'analyze_codebase_patterns',
+            'generate_context_document',
+            'create_validation_loop',
+            'enhance_prompt_with_context',
+            'generate_prp',
+            'extract_documentation_patterns',
+            'analyze_test_patterns',
+            'create_implementation_blueprint'
+        ]
+        
+        for method_name in required_methods:
+            assert hasattr(context_agent, method_name), f"Missing method: {method_name}"
+            assert callable(getattr(context_agent, method_name)), f"Method {method_name} is not callable"
+        
+        print(f"✅ All {len(required_methods)} Context Engineering methods are available")
+        
+        # Test async methods
+        async_methods = [
+            'aanalyze_codebase_patterns',
+            'agenerate_context_document',
+            'acreate_validation_loop',
+            'aenhance_prompt_with_context',
+            'agenerate_prp'
+        ]
+        
+        for method_name in async_methods:
+            assert hasattr(context_agent, method_name), f"Missing async method: {method_name}"
+            assert callable(getattr(context_agent, method_name)), f"Async method {method_name} is not callable"
+        
+        print(f"✅ All {len(async_methods)} async methods are available")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Method availability test failed: {e}")
+        return False
+
+def test_basic_functionality():
+    """Test basic functionality of ContextAgent methods."""
+    print("\\n🧪 Testing Basic Functionality...")
+    
+    try:
+        from praisonaiagents import create_context_agent
+        
+        context_agent = create_context_agent()
+        
+        # Test codebase analysis with current directory
+        test_path = str(Path(__file__).parent.parent)
+        analysis = context_agent.analyze_codebase_patterns(test_path)
+        assert isinstance(analysis, dict), "analyze_codebase_patterns should return dict"
+        print("✅ analyze_codebase_patterns works correctly")
+        
+        # Test context document generation
+        context_doc = context_agent.generate_context_document(
+            project_path=test_path,
+            requirements="Test feature implementation"
+        )
+        assert isinstance(context_doc, str), "generate_context_document should return string"
+        assert len(context_doc) > 100, "Context document should be substantial"
+        print("✅ generate_context_document works correctly")
+        
+        # Test validation loop creation
+        validation = context_agent.create_validation_loop(
+            implementation_requirements="Test implementation",
+            success_criteria=["Test passes", "Code works"]
+        )
+        assert isinstance(validation, dict), "create_validation_loop should return dict"
+        assert 'validation_steps' in validation, "Should have validation_steps"
+        print("✅ create_validation_loop works correctly")
+        
+        # Test prompt enhancement
+        enhanced = context_agent.enhance_prompt_with_context(
+            base_prompt="Test prompt",
+            context_data={"test": "data"}
+        )
+        assert isinstance(enhanced, str), "enhance_prompt_with_context should return string"
+        assert len(enhanced) > len("Test prompt"), "Enhanced prompt should be longer"
+        print("✅ enhance_prompt_with_context works correctly")
+        
+        # Test PRP generation
+        prp = context_agent.generate_prp(
+            feature_request="Test feature",
+            context_analysis=analysis
+        )
+        assert isinstance(prp, str), "generate_prp should return string"
+        assert "PRP" in prp, "Should contain PRP reference"
+        print("✅ generate_prp works correctly")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Functionality test failed: {e}")
+        return False
+
+def test_backward_compatibility():
+    """Test that existing PraisonAI functionality still works."""
+    print("\\n🧪 Testing Backward Compatibility...")
+    
+    try:
+        # Test that we can still import and use existing agents
+        from praisonaiagents import Agent, ImageAgent
+        
+        # Test basic Agent still works
+        basic_agent = Agent(name="Test Agent")  # Agent created for compatibility test
+        print("✅ Basic Agent still works")
+        
+        # Test ImageAgent still works
+        image_agent = ImageAgent(name="Test Image Agent")  # Image agent created for compatibility test
+        print("✅ ImageAgent still works")
+        
+        # Test that we can import other PraisonAI components
+        from praisonaiagents import Task, PraisonAIAgents
+        print("✅ Task and PraisonAIAgents can still be imported")
+        
+        # Test that __all__ exports are working
+        import praisonaiagents
+        expected_exports = [
+            'Agent', 'ImageAgent', 'ContextAgent', 'create_context_agent',
+            'PraisonAIAgents', 'Task'
+        ]
+        
+        for export in expected_exports:
+            assert hasattr(praisonaiagents, export), f"Missing export: {export}"
+        
+        print("✅ All expected exports are available")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Backward compatibility test failed: {e}")
+        return False
+
+def test_syntax_validation():
+    """Test that all Python files have valid syntax."""
+    print("\\n🧪 Testing Syntax Validation...")
+    
+    try:
+        import ast
+        
+        # Test the main ContextAgent file
+        context_agent_file = project_root / "praisonaiagents" / "agent" / "context_agent.py"
+        
+        with open(context_agent_file, 'r') as f:
+            content = f.read()
+        
+        # Parse the file to check for syntax errors
+        ast.parse(content)
+        print("✅ context_agent.py has valid Python syntax")
+        
+        # Test the examples
+        example_files = [
+            Path(__file__).parent.parent.parent.parent / "examples" / "python" / "agents" / "context-agent.py",
+            Path(__file__).parent.parent.parent.parent / "examples" / "python" / "concepts" / "context-engineering-workflow.py"
+        ]
+        
+        for example_file in example_files:
+            if example_file.exists():
+                with open(example_file, 'r') as f:
+                    content = f.read()
+                ast.parse(content)
+                print(f"✅ {example_file.name} has valid Python syntax")
+        
+        return True
+        
+    except SyntaxError as e:
+        print(f"❌ Syntax error found: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Syntax validation failed: {e}")
+        return False
+
+def run_all_tests():
+    """Run all tests and provide summary."""
+    print("🚀 Context Engineering Implementation QA Tests")
+    print("=" * 60)
+    
+    test_results = []
+    
+    # Run all tests
+    test_results.append(("Imports", test_imports()))
+    test_results.append(("Instantiation", test_basic_instantiation()[0]))
+    test_results.append(("Inheritance", test_agent_inheritance()))
+    test_results.append(("Methods", test_context_engineering_methods()))
+    test_results.append(("Functionality", test_basic_functionality()))
+    test_results.append(("Backward Compatibility", test_backward_compatibility()))
+    test_results.append(("Syntax Validation", test_syntax_validation()))
+    
+    # Summary
+    print("\\n📊 Test Results Summary")
+    print("=" * 30)
+    
+    passed = 0
+    total = len(test_results)
+    
+    for test_name, result in test_results:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"   {test_name:<20} {status}")
+        if result:
+            passed += 1
+    
+    print(f"\\n🎯 Overall Result: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! ContextAgent implementation is ready.")
+        return True
+    else:
+        print("⚠️  Some tests failed. Review implementation before release.")
+        return False
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    
+    if success:
+        print("\\n✅ Quality Assurance Complete")
+        print("   • ContextAgent implementation validated")
+        print("   • Backward compatibility confirmed")
+        print("   • All Context Engineering methods working")
+        print("   • Examples have valid syntax")
+        print("   • Ready for production use")
+    else:
+        print("\\n❌ Quality Assurance Failed")
+        print("   • Review failed tests above")
+        print("   • Fix issues before release")
+        
+    sys.exit(0 if success else 1)

src/praisonai-agents/tests/test_embedding_logging.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+Test script to verify that embedding logging is working correctly with TRACE level.
+This test verifies that the TRACE logging level works as expected for embedding operations.
+"""
+
+import logging
+import sys
+import os
+import unittest
+from io import StringIO
+
+# Add the praisonaiagents module to the path using relative path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+sys.path.insert(0, parent_dir)
+
+# Import the memory module to test the logger setup
+try:
+    from praisonaiagents.memory.memory import logger, TRACE_LEVEL
+except ImportError as e:
+    print(f"Failed to import memory module: {e}")
+    sys.exit(1)
+
+
+class TestTraceLogging(unittest.TestCase):
+    """Test cases for TRACE logging functionality."""
+    
+    def setUp(self):
+        """Set up test environment before each test."""
+        # Store original logger level
+        self.original_level = logger.level
+        # Create a string stream to capture log output
+        self.log_capture = StringIO()
+        self.handler = logging.StreamHandler(self.log_capture)
+        self.handler.setLevel(TRACE_LEVEL)
+        self.handler.setFormatter(logging.Formatter('%(levelname)s:%(name)s:%(message)s'))
+        logger.addHandler(self.handler)
+    
+    def tearDown(self):
+        """Clean up after each test."""
+        # Restore original logger level
+        logger.setLevel(self.original_level)
+        # Remove the test handler
+        logger.removeHandler(self.handler)
+        self.handler.close()
+    
+    def test_trace_level_value(self):
+        """Test that TRACE level is set to correct value (5, below DEBUG)."""
+        self.assertEqual(TRACE_LEVEL, 5)
+        self.assertLess(TRACE_LEVEL, logging.DEBUG)  # TRACE should be below DEBUG (10)
+    
+    def test_trace_method_exists(self):
+        """Test that trace method exists on logger."""
+        self.assertTrue(hasattr(logger, 'trace'))
+        self.assertTrue(callable(getattr(logger, 'trace')))
+    
+    def test_trace_logging_at_trace_level(self):
+        """Test that TRACE messages are logged when level is set to TRACE."""
+        logger.setLevel(TRACE_LEVEL)
+        test_message = "Test trace message for embedding data"
+        
+        logger.trace(test_message)
+        
+        log_output = self.log_capture.getvalue()
+        self.assertIn("TRACE", log_output)
+        self.assertIn(test_message, log_output)
+    
+    def test_trace_hidden_at_debug_level(self):
+        """Test that TRACE messages are not logged when level is set to DEBUG."""
+        logger.setLevel(logging.DEBUG)
+        test_message = "Test trace message should be hidden"
+        
+        # Clear any previous output
+        self.log_capture.truncate(0)
+        self.log_capture.seek(0)
+        
+        logger.trace(test_message)
+        
+        log_output = self.log_capture.getvalue()
+        self.assertNotIn(test_message, log_output)
+    
+    def test_trace_hidden_at_info_level(self):
+        """Test that TRACE messages are not logged when level is set to INFO."""
+        logger.setLevel(logging.INFO)
+        test_message = "Test trace message should be hidden at INFO"
+        
+        # Clear any previous output
+        self.log_capture.truncate(0)
+        self.log_capture.seek(0)
+        
+        logger.trace(test_message)
+        
+        log_output = self.log_capture.getvalue()
+        self.assertNotIn(test_message, log_output)
+    
+    def test_debug_still_works_at_debug_level(self):
+        """Test that DEBUG messages still work when level is set to DEBUG."""
+        logger.setLevel(logging.DEBUG)
+        test_message = "Test debug message should be visible"
+        
+        # Clear any previous output
+        self.log_capture.truncate(0)
+        self.log_capture.seek(0)
+        
+        logger.debug(test_message)
+        
+        log_output = self.log_capture.getvalue()
+        self.assertIn("DEBUG", log_output)
+        self.assertIn(test_message, log_output)
+    
+    def test_info_still_works_at_info_level(self):
+        """Test that INFO messages still work when level is set to INFO."""
+        logger.setLevel(logging.INFO)
+        test_message = "Test info message should be visible"
+        
+        # Clear any previous output
+        self.log_capture.truncate(0)
+        self.log_capture.seek(0)
+        
+        logger.info(test_message)
+        
+        log_output = self.log_capture.getvalue()
+        self.assertIn("INFO", log_output)
+        self.assertIn(test_message, log_output)
+    
+    def test_mixed_logging_levels(self):
+        """Test multiple log levels working together at TRACE level."""
+        logger.setLevel(TRACE_LEVEL)
+        
+        # Clear any previous output
+        self.log_capture.truncate(0)
+        self.log_capture.seek(0)
+        
+        logger.info("Info message")
+        logger.debug("Debug message")
+        logger.trace("Trace message")
+        
+        log_output = self.log_capture.getvalue()
+        self.assertIn("INFO", log_output)
+        self.assertIn("DEBUG", log_output)
+        self.assertIn("TRACE", log_output)
+        self.assertIn("Info message", log_output)
+        self.assertIn("Debug message", log_output)
+        self.assertIn("Trace message", log_output)
+
+
+def run_manual_verification():
+    """Run manual verification for visual inspection (can be run standalone)."""
+    print("=== Manual Verification of TRACE Logging ===")
+    print(f"TRACE_LEVEL = {TRACE_LEVEL}")
+    print(f"DEBUG level = {logging.DEBUG}")
+    print()
+    
+    # Configure logging for manual testing
+    logging.basicConfig(
+        level=TRACE_LEVEL,
+        format='%(levelname)s:%(name)s:%(message)s',
+        force=True  # Override any existing configuration
+    )
+    
+    print("--- Testing with TRACE level (all messages should show) ---")
+    logger.setLevel(TRACE_LEVEL)
+    logger.info("This is an INFO message")
+    logger.debug("This is a DEBUG message")
+    logger.trace("This is a TRACE message (embedding data would be here)")
+    
+    print("\n--- Testing with DEBUG level (TRACE should be hidden) ---")
+    logger.setLevel(logging.DEBUG)
+    logger.info("INFO with DEBUG level")
+    logger.debug("DEBUG with DEBUG level")
+    logger.trace("TRACE with DEBUG level (should be hidden)")
+    
+    print("\n--- Testing with INFO level (DEBUG and TRACE should be hidden) ---")
+    logger.setLevel(logging.INFO)
+    logger.info("INFO with INFO level")
+    logger.debug("DEBUG with INFO level (should be hidden)")
+    logger.trace("TRACE with INFO level (should be hidden)")
+    
+    print("\n✅ Manual verification completed!")
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Test embedding TRACE logging implementation")
+    parser.add_argument("--manual", action="store_true", help="Run manual verification with visual output")
+    args = parser.parse_args()
+    
+    if args.manual:
+        print("Running manual verification...")
+        run_manual_verification()
+    else:
+        print("Running automated tests...")
+        # Run the automated tests
+        unittest.main(verbosity=2)

src/praisonai-agents/uv.lock

@@ -2396,7 +2396,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.144"
+version = "0.0.145"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.71.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.71.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.72.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.72.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.2.71 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.2.72 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.71"
+version = "2.2.72"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.144",
+    "praisonaiagents>=0.0.145",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -102,7 +102,7 @@ autogen-v4 = [
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.71"
+version = "2.2.72"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -120,7 +120,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.144"
+praisonaiagents = ">=0.0.145"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"

src/praisonai/uv.lock

@@ -4048,7 +4048,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.2.71"
+version = "2.2.72"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -4202,7 +4202,7 @@ requires-dist = [
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'autogen-v4'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.22" },
-    { name = "praisonaiagents", specifier = ">=0.0.144" },
+    { name = "praisonaiagents", specifier = ">=0.0.145" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = "==0.2.29" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4257,7 +4257,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.144"
+version = "0.0.145"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -4266,9 +4266,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b4/3a/bf0925b182699f4fe9d8b645772ac76126af536755058682922955efe2b1/praisonaiagents-0.0.144.tar.gz", hash = "sha256:5b3870d8bd6679a27a38793d7444f4636fd0bb21b880e4866706dc9f8da783fe", size = 217748, upload-time = "2025-07-18T21:26:38.632Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3e/10/8415fe2c87afb99bde6e29bfc2af480f8e88e2bd685c9690d9bd9f2c030a/praisonaiagents-0.0.145.tar.gz", hash = "sha256:87d3f7f36f8d92874017e2dfb1ab7cafef19303f65c9d5cacdccb733868ca16f", size = 247171, upload-time = "2025-07-20T02:46:15.023Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/41/73/8a89fcb4d8cd17c7dbe43505a671644c283af859ce3984660ad71dbb71d0/praisonaiagents-0.0.144-py3-none-any.whl", hash = "sha256:9907cc4e02d35a20c99a171c723625384937a02f725f00f20a43b7d09ceb7d14", size = 237310, upload-time = "2025-07-18T21:26:37.074Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/18/8531b3b53f8b2654a705e05a75f9f505d93111f048fa26cf39efe43d7018/praisonaiagents-0.0.145-py3-none-any.whl", hash = "sha256:3f79df0519454eae2ca39b899e08f0a9c998d77342aaa6b5ef85f919450b2d73", size = 263461, upload-time = "2025-07-20T02:46:13.2Z" },
 ]
 
 [[package]]