extra knowledge added

app.py

@@ -22,6 +22,32 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 OPENAI_TOKEN = os.getenv("OPENAI_API_KEY")
 
 # --- Custom Tools ---
+class KnowledgeBaseTool(Tool):
+    name = "knowledge_base"
+    description = "Access structured knowledge for common topics"
+    inputs = {"topic": {"type": "string", "description": "The topic to look up"}}
+    output_type = "string"
+    
+    def __init__(self):
+        super().__init__()
+        self.is_initialized = True
+        # Common knowledge base
+        self.knowledge = {
+            "olympics": "Olympic Games data: Countries, athletes, years, sports",
+            "countries": "Country codes: ISO, IOC, FIFA codes and country information",
+            "sports": "Sports history, rules, famous athletes and events",
+            "science": "Scientific facts, formulas, discoveries, and researchers",
+            "history": "Historical events, dates, people, and places",
+            "geography": "Countries, capitals, populations, and geographical features"
+        }
+    
+    def forward(self, topic: str) -> str:
+        topic_lower = topic.lower()
+        for key, info in self.knowledge.items():
+            if key in topic_lower:
+                return f"Knowledge base: {info}. Use this context to answer questions about {topic}."
+        return f"No specific knowledge base entry for '{topic}'. Use general reasoning."
+
 class ReliableSearchTool(Tool):
     name = "reliable_search"
     description = "Search the web for information with built-in retry and fallback mechanisms"
@@ -86,36 +112,48 @@ class SlpMultiAgent:
             max_tokens=1000    # Keep higher tokens for complex reasoning
         )
         
-        # Here you can implement your agent logic, tools, and model calls
-        web_agent = CodeAgent(
-            tools=[ReliableSearchTool(), VisitWebpageTool()],  # Use custom reliable search tool
+        # Create specialized agents
+        research_agent = CodeAgent(
+            tools=[ReliableSearchTool(), KnowledgeBaseTool()],
+            model=model,
+            additional_authorized_imports=["pandas", "time", "json", "requests", "urllib", "re", "datetime"],
+            max_steps=4,
+            name="ResearchAgent",
+            verbosity_level=0,
+            description="Specialized agent for research and fact-finding with knowledge base access."
+        )
+        
+        analysis_agent = CodeAgent(
+            tools=[],
             model=model,
-            additional_authorized_imports=["pandas", "time", "json", "requests", "urllib"],
-            max_steps=5,  # Keep sufficient steps for complex tasks
-            name="WebAgent",
+            additional_authorized_imports=["pandas", "time", "json", "requests", "math", "statistics"],
+            max_steps=3,
+            name="AnalysisAgent",
             verbosity_level=0,
-            description="An agent that can search the web and visit webpages to find information."
+            description="Specialized agent for data analysis, calculations, and logical reasoning."
         )
 
         manager_agent = CodeAgent(
             model=OpenAIServerModel(
                 model_id="gpt-3.5-turbo-16k",
-                temperature=0.1, 
-                max_tokens=1000
+                temperature=0.2,  # Slightly higher for better reasoning variety
+                max_tokens=1200
             ),
-            tools=[],
-            managed_agents=[web_agent],
+            tools=[KnowledgeBaseTool()],
+            managed_agents=[research_agent, analysis_agent],
             name="ManagerAgent",
-            description="A manager agent that can delegate tasks to other agents and manage their execution.",
+            description="A manager agent that coordinates research and analysis agents to solve complex questions.",
             additional_authorized_imports=[
                 "pandas",
                 "time",
                 "json",
-                "requests"
+                "requests",
+                "re",
+                "math"
             ],
-            planning_interval=3,
+            planning_interval=2,
             verbosity_level=1,
-            max_steps=10,  # Keep full steps for complex reasoning
+            max_steps=8,
             final_answer_checks=[check_reasoning]
         )
         
@@ -131,15 +169,19 @@ class SlpMultiAgent:
                     lambda: manager_agent.run(f"""
                     Question: {short_question}
                     
-                    IMPORTANT: You must end with a final_answer() call containing ONLY the direct answer.
+                    You have access to ResearchAgent and AnalysisAgent. Use them strategically:
+                    - ResearchAgent: For finding facts, searching, and knowledge lookup
+                    - AnalysisAgent: For calculations, data processing, and logical reasoning
+                    
+                    Process:
+                    1. Analyze what type of question this is
+                    2. Use knowledge_base() to check for relevant context
+                    3. Delegate to appropriate agents if needed
+                    4. Synthesize information and provide final answer
                     
-                    Steps:
-                    1. Think through the problem
-                    2. Use search if needed with: <code>search_result = reliable_search("query")</code>
-                    3. End with: <code>final_answer("direct answer only")</code>
+                    CRITICAL: End with <code>final_answer("exact answer only")</code>
                     
-                    Do NOT include thoughts, explanations, or reasoning in the final_answer().
-                    The final_answer() should contain only the specific answer requested.
+                    The final_answer must contain ONLY the specific answer requested - no explanations.
                     """)
                 )
                 break  # Success, exit retry loop
@@ -183,13 +225,17 @@ class SlpMultiAgent:
 def check_reasoning(final_answer, agent_memory):
     try:
         # Simple validation - check if answer looks complete
-        if not final_answer or len(final_answer.strip()) < 2:
+        if not final_answer or len(final_answer.strip()) < 1:
             return False
         
         # Check if it's just thoughts/reasoning instead of an answer
-        bad_patterns = ['### Thought:', '### Code:', 'I will', 'Let me', 'First, I', 'Next, I']
+        bad_patterns = ['### Thought:', '### Code:', 'I will', 'Let me', 'First, I', 'Next, I', 'Step 1:', 'Based on']
         if any(pattern in final_answer for pattern in bad_patterns):
             return False
+        
+        # Check if answer is too long (likely contains reasoning)
+        if len(final_answer) > 300:
+            return False
             
         return True  # Pass if it looks like a real answer
     except Exception as e: