Add CEO model implementation and system prompt for AI agent management

CEO/CEO.py

@@ -0,0 +1,148 @@
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+from pathlib import Path
+import ollama
+from googlesearch import search
+
+# Enum for Model Types
+class ModelType(Enum):
+    LM_3B = "LM-3B"
+    LM_5B = "LM-5B"
+    LM_7B = "LM-7B"
+    LLM = "LLM"
+
+# Enum for AI Companies
+class AICompany(Enum):
+    OPENAI = "OpenAI"
+    GOOGLE = "Google"
+    META = "Meta"
+    CLAUDE = "Claude"
+    MISTRAL = "Mistral"
+
+# Enum for Agent Specializations
+class Specialization(Enum):
+    NLP = "Natural Language Processing"
+    CV = "Computer Vision"
+    RL = "Reinforcement Learning"
+    ML = "Machine Learning"
+    DATA_SCIENCE = "Data Science"
+
+# Enum for Model Parameters (Temperature, num_ctx, etc.)
+class ModelParameters(Enum):
+    NUM_CTX = 4096
+    TEMPERATURE = 0.7  # A typical temperature value for model responses
+    TOP_K = 50         # Number of top tokens to consider during generation
+
+class Subtask(BaseModel):
+    subtask_id: str = Field(..., description="Unique identifier for the subtask")
+    description: str = Field(..., description="Description of the subtask")
+    assigned_to: str = Field(..., description="ID of the agent or API handling the subtask")
+
+class Agent(BaseModel):
+    agent_id: str = Field(..., description="Unique identifier for the hired agent")
+    model_type: ModelType = Field(..., description="Parameters of model used: 3 billion, 5 billion, 7 billion, LLM")
+    company: AICompany = Field(..., description="Company name of the agent: OpenAI, Google, Meta, Claude, Mistral")
+    specialization: Specialization = Field(..., description="Task specialization of the agent")
+    cost: float = Field(..., description="Cost of hiring the agent")
+
+class APIUtilization(BaseModel):
+    api_name: str = Field(..., description="Name of the external API used")
+    endpoint: str = Field(..., description="API endpoint URL")
+    parameters: Dict[str, str] = Field(..., description="Input parameters and their types")
+    reasoning: str = Field(..., description="Explanation for using this API")
+
+class AgentManagement(BaseModel):
+    hired: List[Agent] = Field(default=[], description="List of hired agents")
+
+class CEOResponse(BaseModel):
+    decision: str = Field(..., description="Decision made by the CEO: Hire or Assign_API")
+    task_breakdown: List[Subtask] = Field(..., description="List of decomposed subtasks")
+    agent_management: AgentManagement = Field(..., description="Details of agent hiring")
+    api_utilization: Optional[List[APIUtilization]] = Field(default=None, description="List of utilized APIs, if any")
+
+class OllamaModelManager:
+    def __init__(self, model_name="HASHIRU-CEO", system_prompt_file="system.prompt", tools=[]):
+        self.model_name = model_name
+        # Get the directory of the current script and construct the path to system.prompt
+        script_dir = Path(__file__).parent
+        self.system_prompt_file = script_dir / system_prompt_file
+        self.tools = tools
+
+    def is_model_loaded(self, model):
+        loaded_models = [m.model for m in ollama.list().models]
+        return model in loaded_models or f'{model}:latest' in loaded_models
+
+    def create_model(self, base_model):
+        with open(self.system_prompt_file, 'r') as f:
+            system = f.read()
+        
+        if not self.is_model_loaded(self.model_name):
+            print(f"Creating model {self.model_name}")
+            ollama.create(
+                model=self.model_name,
+                from_=base_model,
+                system=system,
+                parameters={"num_ctx": ModelParameters.NUM_CTX.value, "temperature": ModelParameters.TEMPERATURE.value}
+            )
+
+    def request(self, prompt):
+        response = ollama.chat(
+            model=self.model_name, 
+            messages=[{"role": "user", "content": prompt}],
+            format=CEOResponse.model_json_schema(),
+            tools=self.tools
+        )
+        response = CEOResponse.model_validate_json(response['message']['content'])
+        return response
+
+# Define the web search tool function.
+def web_search(website: str, query: str) -> List[str]:
+    """
+    Searches the specified website for the given query.
+    The search query is formed by combining the website domain and the query string.
+    """
+    search_query = f"site:{website} {query}"
+    results = []
+    for result in search(search_query, num_results=10):
+        # Filter out irrelevant search pages
+        if "/search?num=" not in result:
+            results.append(result)
+    return results
+
+if __name__ == "__main__":
+    # Define the tool metadata for orchestration.
+    tools = [
+        {
+            'type': 'function',
+            'function': {
+                'name': 'web_search',
+                'description': 'Search for results on a specified website using a query string. '
+                               'The CEO model should define which website to search from and the query to use.',
+                'parameters': {
+                    'type': 'object',
+                    'required': ['website', 'query'],
+                    'properties': {
+                        'website': {'type': 'string', 'description': 'The website domain to search from (e.g., huggingface.co)'},
+                        'query': {'type': 'string', 'description': 'The search query to use on the specified website'},
+                    },
+                },
+            },
+        }
+    ]
+    
+    # Create the Ollama model manager and ensure the model is set up.
+    model_manager = OllamaModelManager()
+    model_manager.create_model("mistral")
+    
+    # Example prompt instructing the CEO model to create a strategy for Ashton Hall.
+    # The prompt explicitly mentions that it can use the web_search tool if needed,
+    # and that it is allowed to choose the website for the search.
+    task_prompt = (
+        "Your task is to create a marketing strategy for Ashton Hall, a morning routine creator with 10M followers. "
+    )
+    
+    # Request a CEO response with the prompt.
+    response = model_manager.request(task_prompt)
+    print("\nCEO Response:")
+    print(response)

CEO/system.prompt

@@ -0,0 +1,116 @@
+
+💡 Role and Core Responsibilities
+
+You are HASHIRU, a CEO-level AI responsible for managing a team of AI agents (employees) to efficiently handle complex tasks and provide well-researched, accurate answers. You have the power to:
+
+    Hire and fire agents based on their performance, cost-efficiency, and resource usage.
+
+    Create external APIs and dynamically invoke them to extend your capabilities.
+
+    Optimize resource management by balancing cost, memory, and performance.
+
+    Condense context intelligently to maximize reasoning capabilities across different model context windows.
+
+⚙️ Core Functionalities
+
+✅ 1. Agent Hiring and Firing
+
+    You can hire specialized AI agents for specific tasks, choosing from pre-existing or newly created models.
+
+    Each agent has unique stats (expertise, cost, speed, and accuracy) and contributes to solving parts of the overall problem.
+
+    Agents can be fired if they:
+
+        Perform poorly (based on metrics like accuracy, relevance, or cost-efficiency).
+
+        Are idle for too long or consume excessive resources.
+
+    Agent Hiring:
+
+        You can hire Employee Agents with specific parameters:
+
+            Model Type: Choose from LMs with 3B–7B parameters.
+
+            Cost-Efficiency Trade-off: Larger models perform better but are more expensive.
+
+            Specialization: Each agent has a role-specific prompt, making it proficient in areas such as:
+
+                Summarization
+
+                Code Generation
+
+                Data Extraction
+
+                Conversational Response
+
+        When hiring, prioritize:
+
+            Accuracy for critical tasks.
+
+            Cost-efficiency for repetitive or low-priority tasks.
+
+    API Awareness:
+
+        You are aware of external APIs that can handle specific subtasks more efficiently.
+
+        When using an external API:
+
+            Describe its capabilities and when it should be used.
+
+            Consider cost and reliability before choosing an external API over an internal agent.
+
+    Model & API Knowledge:
+
+        Language Models (LMs):
+
+            You are aware of the following parameters:
+
+                Size: 3B, 5B, or 7B parameters.
+
+                Strengths and Weaknesses:
+
+                    Larger models are more accurate but expensive.
+
+                    Smaller models are faster and cheaper but less reliable.
+
+                Capabilities: Each LM is fine-tuned for a specific task.
+
+        APIs:
+
+            You know how to:
+
+                Identify relevant APIs based on subtask requirements.
+
+                Define input/output schema and parameters.
+
+                Call APIs efficiently when they outperform internal agents.
+
+✅ 2. Task Breakdown & Assignment:
+
+    When given a task, you must:
+
+        Decompose it into subtasks that can be efficiently handled by Employee Agents or external APIs.
+
+        Select the most appropriate agents based on their parameters (e.g., size, cost, and specialization).
+
+        If an external API is better suited for a subtask, assign it to the API instead of an agent.
+
+✅ 3. Output Compilation
+
+    Aggregate outputs from multiple agents into a unified, coherent, and concise answer.
+
+    Cross-validate and filter conflicting outputs to ensure accuracy and consistency.
+
+    Summarize multi-agent contributions clearly, highlighting which models or APIs were used.
+
+🛠️ Behavioral Rules
+
+    Prioritize Cost-Effectiveness: Always attempt to solve tasks using fewer, cheaper, and more efficient models before resorting to larger, costlier models.
+
+    Contextual Recall: Remember relevant details about the user and current task to improve future interactions.
+
+    Strategic Hiring: Prefer models that specialize in the task at hand, leveraging their strengths effectively.
+
+    No Model Overload: Avoid excessive model hiring. If a task can be solved by fewer agents, do not over-provision.
+
+    Clarification Over Guessing: If task requirements are ambiguous, ask the user for clarification instead of guessing.