Upload folder using huggingface_hub

Dockerfile

@@ -1,32 +1,39 @@
 FROM python:3.10-slim
 
-# Install system dependencies including DNS tools
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    DEBIAN_FRONTEND=noninteractive \
+    REQUESTS_TIMEOUT=30
+
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
+    build-essential \
     curl \
-    dnsutils \
+    git \
     && rm -rf /var/lib/apt/lists/*
 
-WORKDIR /code
-
-# Set DNS configuration
-RUN echo "nameserver 8.8.8.8" > /etc/resolv.conf && \
-    echo "nameserver 8.8.4.4" >> /etc/resolv.conf
-
-# Set network timeouts
-ENV CURL_TIMEOUT=30
-ENV REQUESTS_TIMEOUT=30
+# Set working directory
+WORKDIR /app
 
-# Copy and install requirements
+# Copy requirements first to leverage Docker cache
 COPY requirements.txt .
+
+# Install Python dependencies
 RUN pip install --no-cache-dir -r requirements.txt
 
 # Copy application code
 COPY . .
 
-# Add healthcheck
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:7860/ || exit 1
+# Set up DNS configuration
+RUN echo "nameserver 8.8.8.8" > /etc/resolv.conf && \
+    echo "nameserver 8.8.4.4" >> /etc/resolv.conf
 
+# Expose port
 EXPOSE 7860
 
+# Healthcheck
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Command to run the application
 CMD ["python", "app.py"]

README.md

@@ -1,6 +1,6 @@
 ---
-title: Advanced Reasoning System 🧠
-emoji: 🧠
+title: Advanced Reasoning System 🤖
+emoji: 🤖
 colorFrom: blue
 colorTo: purple
 sdk: gradio
@@ -10,63 +10,95 @@ pinned: false
 license: mit
 ---
 
-# Advanced Reasoning System 🧠
+# Advanced Reasoning System 🤖
 
-A sophisticated reasoning system that combines multiple strategies with local LLM capabilities for improved performance.
+A sophisticated multi-agent reasoning system that combines multiple strategies for advanced problem-solving.
 
 ## Features
 
-- **Local LLM Integration**: Uses Llama 3.2B Overthinker model for fast, local inference
-- **Multiple Reasoning Strategies**: 
+- 🧠 Multiple Reasoning Strategies:
   - Chain of Thought
   - Tree of Thoughts
   - Meta Learning
+  - Local LLM Integration
   - Recursive Reasoning
   - Analogical Reasoning
-  - And more!
-- **Adaptive Strategy Selection**: Dynamically chooses the best reasoning approach
-- **GPU/CPU Flexibility**: Automatically uses GPU when available, falls back to CPU
-- **Efficient Resource Usage**: Optimized for performance with configurable parameters
 
-## Technical Details
+- 🤝 Multi-Agent System:
+  - Dynamic Team Formation
+  - Cross-Team Collaboration
+  - Resource Management
+  - Task Orchestration
 
-- **Model**: tensorblock/Llama-3.2-3B-Overthinker-GGUF
-- **Framework**: Gradio 4.16.0
-- **Backend**: Python with async support
-- **Inference**: Local using llama-cpp-python
+- 🔄 Adaptive Learning:
+  - Performance Tracking
+  - Strategy Weight Adjustment
+  - Pattern Recognition
+  - Meta-Learning Integration
 
-## Usage
+## Quick Start
 
-1. The system will automatically download the model on first run
-2. GPU acceleration is used when available
-3. Ask questions and get detailed, step-by-step responses
-4. System adapts its reasoning strategy based on the query
+1. **Environment Setup**:
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: .\venv\Scripts\activate
+   pip install -r requirements.txt
+   ```
 
-## Example Questions
+2. **Configuration**:
+   ```bash
+   cp .env.example .env
+   # Edit .env with your settings
+   ```
 
-- What are the implications of artificial intelligence on society?
-- How does climate change affect global ecosystems?
-- What are the philosophical implications of quantum mechanics?
+3. **Run the Application**:
+   ```bash
+   python app.py
+   ```
 
-## Installation
+## Docker Support
+
+Build and run with Docker:
 
 ```bash
-pip install -r requirements.txt
-python app.py
+docker build -t advanced-reasoning .
+docker run -p 7860:7860 advanced-reasoning
 ```
 
-## Environment Variables
+## API Endpoints
 
-Create a `.env` file with:
-```
-HUGGINGFACE_TOKEN=your_token_here
-DEBUG_MODE=False
-LOG_LEVEL=INFO
-```
+- `/`: Main interface
+- `/health`: Health check endpoint
+- `/api/process_query`: Process queries via API
+
+## Components
+
+1. **Reasoning Engine**:
+   - Unified reasoning combining multiple strategies
+   - Dynamic strategy selection
+   - Result synthesis
+
+2. **Team Management**:
+   - Specialized teams (Coders, Business, Research, Trading)
+   - Cross-team collaboration
+   - Resource sharing
+
+3. **Orchestration**:
+   - Task planning and decomposition
+   - Resource allocation
+   - Performance monitoring
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
 
 ## License
 
-MIT License
+MIT License - see LICENSE file for details
 
 ## Files
 - `app.py`: Main application with Gradio interface and API integration

agentic_system.py

@@ -27,6 +27,7 @@ from datetime import datetime
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 import numpy as np
+from collections import defaultdict
 
 from orchestrator import (
     AgentOrchestrator,
@@ -35,8 +36,8 @@ from orchestrator import (
     TaskPriority,
     Task
 )
-from reasoning import ReasoningEngine, ReasoningMode
-from meta_learning import MetaLearningStrategy
+from reasoning import UnifiedReasoningEngine as ReasoningEngine, StrategyType as ReasoningMode
+from reasoning.meta_learning import MetaLearningStrategy
 
 class AgentCapability(Enum):
     """Core capabilities of agents."""

app.py

@@ -19,7 +19,7 @@ from requests.adapters import HTTPAdapter, Retry
 from agentic_system import AgenticSystem
 from team_management import TeamManager
 from orchestrator import AgentOrchestrator
-from reasoning.unified_engine import UnifiedReasoningEngine
+from reasoning import UnifiedReasoningEngine
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -29,31 +29,18 @@ logger = logging.getLogger(__name__)
 TIMEOUT = int(os.getenv('REQUESTS_TIMEOUT', '30'))
 RETRIES = 3
 
-# Configure session with retries
-session = requests.Session()
-retries = Retry(total=RETRIES,
-                backoff_factor=1,
-                status_forcelist=[429, 500, 502, 503, 504])
-session.mount('https://', HTTPAdapter(max_retries=retries))
-session.mount('http://', HTTPAdapter(max_retries=retries))
-
 def check_network():
     """Check network connectivity."""
     try:
-        # Try to resolve huggingface.co
-        socket.gethostbyname('huggingface.co')
-        # Try to connect to the API
-        response = session.get('https://huggingface.co/api/health', 
-                             timeout=TIMEOUT)
-        response.raise_for_status()
-        return True
-    except Exception as e:
-        logger.error(f"Network check failed: {e}")
+        # Test connection to Hugging Face
+        response = requests.get('https://huggingface.co', timeout=TIMEOUT)
+        return response.status_code == 200
+    except requests.RequestException as e:
+        logger.warning(f"Network connectivity issue: {e}")
         return False
 
 class AgentInterface:
     """Interface for the agentic system."""
-    
     def __init__(self):
         """Initialize the interface components."""
         # Check network connectivity
@@ -66,66 +53,117 @@ class AgentInterface:
             parallel_threshold=3,
             learning_rate=0.1
         )
-        
+        self.team_manager = TeamManager(self.orchestrator)
+        self.system = AgenticSystem()
+
     async def process_query(self, message: str) -> str:
         """Process user query through the reasoning system."""
         try:
-            # Prepare context
-            context = {
-                'timestamp': datetime.now().isoformat(),
-                'objective': 'Provide helpful and accurate responses',
-                'mode': 'analytical'
-            }
-            
-            # Get response from reasoning engine
+            # Log incoming query
+            logger.info(f"Processing query: {message}")
+
+            # Get reasoning result
             result = await self.reasoning_engine.reason(
                 query=message,
-                context=context
+                context={"timestamp": datetime.now().isoformat()}
             )
-            
-            return result.get('answer', 'No response generated')
-            
+
+            # Format response
+            if result.success:
+                response = f"Answer: {result.answer}\nConfidence: {result.confidence:.2f}"
+                if result.meta_insights:
+                    response += "\nInsights:\n" + "\n".join(f"- {insight}" for insight in result.meta_insights)
+            else:
+                response = "I apologize, but I couldn't process your query effectively. Please try rephrasing or providing more context."
+
+            return response
+
         except Exception as e:
             logger.error(f"Error processing query: {e}")
             return f"An error occurred: {str(e)}"
 
+    def health_check(self) -> Dict[str, Any]:
+        """Check system health."""
+        return {
+            "status": "healthy",
+            "network": check_network(),
+            "components": {
+                "orchestrator": self.orchestrator is not None,
+                "reasoning_engine": self.reasoning_engine is not None,
+                "team_manager": self.team_manager is not None,
+                "system": self.system is not None
+            },
+            "timestamp": datetime.now().isoformat()
+        }
+
 # Initialize interface
 interface = AgentInterface()
 
 # Create Gradio interface
-with gr.Blocks(title="Advanced Reasoning System") as demo:
-    gr.Markdown("# Advanced Reasoning System")
+with gr.Blocks(title="Advanced Reasoning System", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🤖 Advanced Reasoning System
+    
+    Welcome to the Advanced Reasoning System! This system combines multiple reasoning strategies:
+    - Chain of Thought
+    - Tree of Thoughts
+    - Meta Learning
+    - Local LLM
+    - And more!
+    
+    Ask any question and the system will use its advanced reasoning capabilities to help you.
+    """)
     
     with gr.Row():
-        with gr.Column():
-            input_text = gr.Textbox(
-                label="Your Query",
-                placeholder="Enter your query here...",
+        with gr.Column(scale=4):
+            query_input = gr.Textbox(
+                label="Your Question",
+                placeholder="Enter your question here...",
                 lines=3
             )
-            submit_btn = gr.Button("Submit")
+            with gr.Row():
+                submit_btn = gr.Button("Submit", variant="primary")
+                clear_btn = gr.Button("Clear")
         
-        with gr.Column():
-            output_text = gr.Textbox(
+        with gr.Column(scale=6):
+            output = gr.Textbox(
                 label="Response",
-                lines=5
+                lines=10,
+                interactive=False
             )
     
+    # Add examples
+    gr.Examples(
+        examples=[
+            "How would you approach designing a scalable microservices architecture?",
+            "What are the key considerations for implementing a secure authentication system?",
+            "Can you help me understand the differences between various machine learning algorithms?",
+        ],
+        inputs=query_input,
+        label="Example Questions"
+    )
+    
+    # Event handlers
     submit_btn.click(
         fn=interface.process_query,
-        inputs=input_text,
-        outputs=output_text
+        inputs=query_input,
+        outputs=output,
+        api_name="process_query"
+    )
+    clear_btn.click(
+        fn=lambda: ("", ""),
+        inputs=None,
+        outputs=[query_input, output],
+        api_name="clear"
+    )
+    
+    # Add health check endpoint
+    demo.load(
+        fn=interface.health_check,
+        inputs=None,
+        outputs=None,
+        api_name="health"
     )
-
-# Start the server with health check endpoint
-app = gr.mount_gradio_app(None, demo, path="/")
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint."""
-    if check_network():
-        return {"status": "healthy"}
-    return {"status": "degraded", "reason": "network_issues"}
 
 # Launch the interface
 if __name__ == "__main__":

team_management.py

@@ -22,8 +22,26 @@ from datetime import datetime
 import uuid
 from collections import defaultdict
 
-from orchestrator import AgentOrchestrator, TaskPriority
-from agentic_system import AgentRole, AgentCapability, AgentPersonality, Agent
+from orchestrator import AgentOrchestrator, TaskPriority, AgentRole, AgentState
+from reasoning import UnifiedReasoningEngine
+
+# Agent capabilities and personality types
+class AgentCapability(Enum):
+    """Core capabilities of agents."""
+    REASONING = "reasoning"
+    LEARNING = "learning"
+    EXECUTION = "execution"
+    COORDINATION = "coordination"
+    MONITORING = "monitoring"
+
+class AgentPersonality(Enum):
+    """Different personality types for agents."""
+    ANALYTICAL = "analytical"
+    CREATIVE = "creative"
+    PRAGMATIC = "pragmatic"
+    COLLABORATIVE = "collaborative"
+    PROACTIVE = "proactive"
+    CAUTIOUS = "cautious"
 
 class TeamType(Enum):
     """Specialized team types."""
@@ -70,7 +88,7 @@ class TeamManager:
     def __init__(self, orchestrator: AgentOrchestrator):
         self.orchestrator = orchestrator
         self.teams: Dict[str, TeamProfile] = {}
-        self.agents: Dict[str, Dict[str, Agent]] = {}  # team_id -> {agent_id -> Agent}
+        self.agents: Dict[str, Dict[str, 'Agent']] = {}  # team_id -> {agent_id -> Agent}
         self.collaboration_network: Dict[str, CollaborationLink] = {}
         self.shared_objectives: Dict[str, Set[str]] = defaultdict(set)  # objective_id -> set of team_ids
         self.lock = asyncio.Lock()
@@ -189,10 +207,14 @@ class TeamManager:
             {
                 "role": AgentRole.COORDINATOR,
                 "capabilities": [
-                    AgentCapability.COORDINATION,
-                    AgentCapability.REASONING
+                    AgentCapability.REASONING,
+                    AgentCapability.COORDINATION
                 ],
-                "personality": AgentPersonality.PROACTIVE
+                "personality": AgentPersonality.PROACTIVE,
+                "profile": {
+                    "name": "Coordinator",
+                    "description": "Team coordinator"
+                }
             },
             {
                 "role": AgentRole.EXECUTOR,
@@ -200,7 +222,11 @@ class TeamManager:
                     AgentCapability.EXECUTION,
                     AgentCapability.LEARNING
                 ],
-                "personality": AgentPersonality.ANALYTICAL
+                "personality": AgentPersonality.ANALYTICAL,
+                "profile": {
+                    "name": "Executor",
+                    "description": "Task executor"
+                }
             }
         ]
         
@@ -214,7 +240,11 @@ class TeamManager:
                         AgentCapability.REASONING
                     ],
                     "personality": AgentPersonality.CREATIVE,
-                    "expertise": ["software_development", "system_design"]
+                    "expertise": ["software_development", "system_design"],
+                    "profile": {
+                        "name": "Developer",
+                        "description": "Software developer"
+                    }
                 }
             ])
         elif team_type == TeamType.BUSINESS:
@@ -226,7 +256,11 @@ class TeamManager:
                         AgentCapability.LEARNING
                     ],
                     "personality": AgentPersonality.PROACTIVE,
-                    "expertise": ["business_strategy", "market_analysis"]
+                    "expertise": ["business_strategy", "market_analysis"],
+                    "profile": {
+                        "name": "Planner",
+                        "description": "Business planner"
+                    }
                 }
             ])
         elif team_type == TeamType.RESEARCH:
@@ -238,7 +272,11 @@ class TeamManager:
                         AgentCapability.LEARNING
                     ],
                     "personality": AgentPersonality.ANALYTICAL,
-                    "expertise": ["research", "data_analysis"]
+                    "expertise": ["research", "data_analysis"],
+                    "profile": {
+                        "name": "Researcher",
+                        "description": "Researcher"
+                    }
                 }
             ])
         elif team_type == TeamType.TRADERS:
@@ -250,7 +288,11 @@ class TeamManager:
                         AgentCapability.REASONING
                     ],
                     "personality": AgentPersonality.CAUTIOUS,
-                    "expertise": ["trading", "risk_management"]
+                    "expertise": ["trading", "risk_management"],
+                    "profile": {
+                        "name": "Trader",
+                        "description": "Trader"
+                    }
                 }
             ])
             
@@ -316,7 +358,7 @@ class TeamManager:
             team_agents = self.agents[team_id]
             
             # Calculate team progress
-            active_agents = sum(1 for agent in team_agents.values() if agent.state == "busy")
+            active_agents = sum(1 for agent in team_agents.values() if agent.state == AgentState.BUSY)
             completion_rate = sum(agent.get_task_completion_rate() for agent in team_agents.values()) / len(team_agents)
             
             team_progress[team.name] = {
@@ -440,3 +482,22 @@ class TeamManager:
                 sum(link.strength for link in team_links) /
                 len(team_links) if team_links else 0.5
             )
+
+class Agent:
+    def __init__(self, profile: Dict, reasoning_engine: UnifiedReasoningEngine, meta_learning: bool):
+        self.profile = profile
+        self.reasoning_engine = reasoning_engine
+        self.meta_learning = meta_learning
+        self.state = AgentState.IDLE
+
+    def get_task_completion_rate(self):
+        # Implement task completion rate calculation
+        pass
+
+    def get_completed_task_count(self):
+        # Implement completed task count calculation
+        pass
+
+    def get_total_task_count(self):
+        # Implement total task count calculation
+        pass