enhance iterative agentic loop and optimize configuration settings

agent.py

@@ -2,6 +2,8 @@
 FleetMind AI Agent
 Autonomous fleet management agent using Gemini 2.0 Flash
 Track 2: MCP in Action - Enterprise Category
+
+FIXED: True iterative agentic loop - Gemini sees tool results and decides next action
 """
 
 import json
@@ -44,6 +46,7 @@ class FleetMindAgent:
     Uses Gemini 2.0 Flash for reasoning and MCP tools for execution
 
     Advanced Features:
+    - TRUE ITERATIVE AGENTIC LOOP: Model sees each tool result before deciding next action
     - Context Engineering: Smart conversation memory with summarization
     - Multi-step Planning: Complex task breakdown and execution
     - Reasoning Transparency: Detailed explanation of decision-making
@@ -60,12 +63,12 @@ class FleetMindAgent:
         self.task_context: dict = {}  # Current task context
         self.max_history_length = 20  # Max messages before summarization
 
-        # Initialize Gemini
+        # Initialize Gemini - CRITICAL: temperature=1.0 for Gemini 2.0 reasoning
         genai.configure(api_key=gemini_api_key)
         self.model = genai.GenerativeModel(
             model_name=Config.GEMINI_MODEL,
             generation_config={
-                "temperature": Config.AGENT_TEMPERATURE,
+                "temperature": 1.0,  # IMPORTANT: Gemini 2.0 reasoning optimized for 1.0
                 "top_p": 0.95,
                 "top_k": 40,
                 "max_output_tokens": 8192,
@@ -149,17 +152,17 @@ Provide a concise summary in 3-4 sentences."""
 
         return "\n\n".join(schema_parts)
 
-    def _create_prompt(self, user_message: str) -> str:
+    def _create_iterative_prompt(self, user_message: str, execution_context: list[dict]) -> str:
         """
-        Create the full prompt for the AI model with Context Engineering
-        Includes conversation summary, user preferences, and task context
+        Create prompt for iterative agentic loop.
+        Includes previous tool results so model can make informed decisions.
         """
         # Get current date/time for context
         now = datetime.now()
         current_time = now.strftime("%Y-%m-%d %H:%M:%S")
         default_delivery_time = (now + timedelta(hours=2)).strftime("%Y-%m-%dT%H:%M:%S")
 
-        # Build context with Context Engineering enhancements
+        # Build context
         context = f"""
 Current Date/Time: {current_time}
 Default Expected Delivery Time (if not specified): {default_delivery_time}
@@ -168,11 +171,11 @@ Connected to MCP Server: {self.mcp_client.is_connected}
 Available Tools: {len(self.mcp_client.tools)}
 """
 
-        # Add conversation summary if available (Context Engineering)
+        # Add conversation summary if available
         if self.context_summary:
             context += f"\n**Conversation Summary**: {self.context_summary}\n"
 
-        # Add learned user preferences (Context Engineering)
+        # Add learned user preferences
         if self.user_preferences:
             prefs_text = "\n**Learned User Preferences**:\n"
             if self.user_preferences.get("prefers_urgent"):
@@ -181,8 +184,8 @@ Available Tools: {len(self.mcp_client.tools)}
                 prefs_text += "- User frequently handles fragile items\n"
             context += prefs_text
 
-        # Recent conversation context (limited to prevent overflow)
-        recent_history = self.conversation_history[-6:] if self.conversation_history else []
+        # Recent conversation history
+        recent_history = self.conversation_history[-4:] if self.conversation_history else []
         history_text = ""
         if recent_history:
             history_text = "\n\n**Recent Conversation**:\n"
@@ -194,39 +197,83 @@ Available Tools: {len(self.mcp_client.tools)}
         # Tool schema
         tools_schema = self._build_tools_schema()
 
+        # Build execution context string showing what's been done
+        execution_history = ""
+        if execution_context:
+            execution_history = "\n\n## EXECUTION HISTORY (What you've done so far)\n"
+            for step in execution_context:
+                step_num = step.get("step", "?")
+                tool_name = step.get("tool", "N/A")
+                args = step.get("arguments", {})
+                result = step.get("result", "N/A")
+                execution_history += f"""
+### Step {step_num}: Called {tool_name}
+Arguments: {json.dumps(args, indent=2)}
+Result: {json.dumps(result, indent=2) if isinstance(result, dict) else result}
+"""
+
         return f"""{AGENT_SYSTEM_PROMPT}
 
+═══════════════════════════════════════════════════════════════
+⚡ CRITICAL: ITERATIVE AGENTIC REASONING
+═══════════════════════════════════════════════════════════════
+
+You are in an ITERATIVE LOOP. Each turn, you can call ONE tool or finish.
+After each tool call, you will see the result and decide the NEXT step.
+
+**WORKFLOW:**
+1. Analyze what the user wants
+2. Determine the NEXT SINGLE action needed
+3. Either call a tool OR provide final response
+
+**RESPONSE FORMAT (STRICT JSON):**
+
+If you need to call a tool:
+```json
+{{
+    "thinking": "My reasoning about what to do next...",
+    "action": "call_tool",
+    "tool": "tool_name",
+    "arguments": {{}},
+    "status": "in_progress"
+}}
+```
+
+If you're DONE (all steps complete):
+```json
+{{
+    "thinking": "Summarizing what was accomplished...",
+    "action": "respond",
+    "message": "Your final response to the user",
+    "status": "complete"
+}}
+```
+
+**IMPORTANT RULES:**
+1. Call ONE tool at a time - you'll see the result before deciding next step
+2. USE ACTUAL DATA from previous tool results (coordinates, IDs, etc.)
+3. Don't guess values - use what the tools returned
+4. After geocoding, USE the lat/lng from the result in subsequent calls
+5. After creating order, USE the order_id for assignment
+
+═══════════════════════════════════════════════════════════════
+
 ## Context
 {context}
 {history_text}
 
 ## Available Tools Schema
 {tools_schema}
+{execution_history}
 
-## User Request
+## Current User Request
 {user_message}
 
-## Your Response Format
-Respond with a JSON object containing:
-{{
-    "reasoning": "Your step-by-step thinking process (be detailed and explain WHY you choose certain actions)",
-    "plan": [
-        {{
-            "step": 1,
-            "action": "Description of what you're doing",
-            "tool": "tool_name or null if no tool needed",
-            "arguments": {{}} // tool arguments if applicable
-        }}
-    ],
-    "final_message": "Your response to the user after executing the plan"
-}}
-
-If no tools are needed (e.g., answering a question), set plan to an empty array.
-IMPORTANT: Only include the JSON object in your response, no other text.
+## Your Next Action (JSON only, no other text)
 """
 
-    def _parse_ai_response(self, response_text: str) -> dict:
-        """Parse the AI's JSON response"""
+    def _parse_iterative_response(self, response_text: str) -> dict:
+        """Parse the AI's JSON response for iterative loop"""
         # Try to extract JSON from the response
         try:
             # First try direct parse
@@ -250,21 +297,21 @@ IMPORTANT: Only include the JSON object in your response, no other text.
             except json.JSONDecodeError:
                 pass
 
-        # Fallback: return as simple message
+        # Fallback: treat as final response
         return {
-            "reasoning": "Direct response",
-            "plan": [],
-            "final_message": response_text
+            "thinking": "Direct response",
+            "action": "respond",
+            "message": response_text,
+            "status": "complete"
         }
 
     async def process_message(self, user_message: str) -> AgentResponse:
         """
-        Process a user message and return the agent's response
+        Process a user message using TRUE ITERATIVE AGENTIC LOOP.
 
-        Context Engineering Applied:
-        - Summarizes long conversations to prevent context overflow
-        - Learns and applies user preferences
-        - Maintains task context across messages
+        The model calls ONE tool at a time, sees the result, then decides
+        the next action. This allows proper use of tool results (like coordinates
+        from geocoding) in subsequent calls (like create_order).
 
         Args:
             user_message: The user's natural language input
@@ -282,57 +329,99 @@ IMPORTANT: Only include the JSON object in your response, no other text.
             "content": user_message
         })
 
-        # Generate AI response
-        prompt = self._create_prompt(user_message)
-
-        try:
-            response = self.model.generate_content(prompt)
-            ai_response_text = response.text
-        except Exception as e:
-            return AgentResponse(
-                message=f"Error generating AI response: {str(e)}",
-                success=False,
-                error=str(e)
-            )
-
-        # Parse the response
-        parsed = self._parse_ai_response(ai_response_text)
-        reasoning = parsed.get("reasoning", "")
-        plan = parsed.get("plan", [])
-        final_message = parsed.get("final_message", "")
-
-        # Execute the plan
+        # Initialize execution tracking
+        execution_context: list[dict] = []
         steps: list[AgentStep] = []
         tools_called: list[str] = []
+        all_reasoning: list[str] = []
+        final_message = ""
 
-        for i, step_plan in enumerate(plan[:self.max_tool_calls]):
-            step = AgentStep(
-                step_number=i + 1,
-                action=step_plan.get("action", ""),
-                tool_name=step_plan.get("tool"),
-                tool_args=step_plan.get("arguments", {}),
-                reasoning=step_plan.get("reasoning", "")
-            )
+        # ITERATIVE AGENTIC LOOP
+        max_iterations = self.max_tool_calls + 2  # Allow extra iterations for reasoning
+        iteration = 0
 
-            # Execute tool if specified
-            if step.tool_name:
-                tool_result = await self.mcp_client.call_tool(
-                    step.tool_name,
-                    step.tool_args
-                )
-                step.result = tool_result.result if tool_result.success else tool_result.error
-                tools_called.append(step.tool_name)
+        while iteration < max_iterations:
+            iteration += 1
+            print(f"\n🔄 Agent Iteration {iteration}/{max_iterations}")
 
-                # If tool failed, note it
-                if not tool_result.success:
-                    step.action += f" (FAILED: {tool_result.error})"
+            # Generate next action
+            prompt = self._create_iterative_prompt(user_message, execution_context)
 
-            steps.append(step)
+            try:
+                response = self.model.generate_content(prompt)
+                ai_response_text = response.text
+                print(f"📝 AI Response: {ai_response_text[:500]}...")
+            except Exception as e:
+                return AgentResponse(
+                    message=f"Error generating AI response: {str(e)}",
+                    success=False,
+                    error=str(e)
+                )
 
-        # If we executed tools, regenerate final message with results
+            # Parse the response
+            parsed = self._parse_iterative_response(ai_response_text)
+            thinking = parsed.get("thinking", "")
+            action = parsed.get("action", "respond")
+            status = parsed.get("status", "complete")
+
+            all_reasoning.append(f"Step {iteration}: {thinking}")
+
+            # Check if agent wants to call a tool
+            if action == "call_tool" and status != "complete":
+                tool_name = parsed.get("tool")
+                tool_args = parsed.get("arguments", {})
+
+                if not tool_name:
+                    print("⚠️ No tool specified, treating as complete")
+                    final_message = parsed.get("message", thinking)
+                    break
+
+                print(f"🔧 Calling tool: {tool_name}")
+                print(f"   Args: {json.dumps(tool_args, indent=2)}")
+
+                # Execute the tool
+                tool_result = await self.mcp_client.call_tool(tool_name, tool_args)
+
+                result_data = tool_result.result if tool_result.success else {"error": tool_result.error}
+                print(f"   Result: {json.dumps(result_data, indent=2) if isinstance(result_data, dict) else result_data}")
+
+                # Record the step
+                step = AgentStep(
+                    step_number=len(steps) + 1,
+                    action=thinking,
+                    tool_name=tool_name,
+                    tool_args=tool_args,
+                    result=result_data,
+                    reasoning=thinking
+                )
+                steps.append(step)
+                tools_called.append(tool_name)
+
+                # Add to execution context for next iteration
+                execution_context.append({
+                    "step": len(execution_context) + 1,
+                    "tool": tool_name,
+                    "arguments": tool_args,
+                    "result": result_data,
+                    "success": tool_result.success
+                })
+
+                # Continue the loop - model will see this result next iteration
+
+            else:
+                # Agent is done - extract final message
+                final_message = parsed.get("message", thinking)
+                print(f"✅ Agent complete: {final_message[:200]}...")
+                break
+
+        # If we hit max iterations without completing
+        if not final_message:
+            final_message = "I completed several operations. Please check the results above."
+
+        # Generate a nicely formatted final response if we have steps
         if steps:
             final_message = await self._generate_final_response(
-                user_message, steps, reasoning
+                user_message, steps, "\n".join(all_reasoning)
             )
 
         # Add assistant response to history
@@ -347,7 +436,7 @@ IMPORTANT: Only include the JSON object in your response, no other text.
         return AgentResponse(
             message=final_message,
             steps=steps,
-            reasoning=reasoning,
+            reasoning="\n".join(all_reasoning),
             tools_called=tools_called,
             success=True
         )

config.py

@@ -22,8 +22,8 @@ class Config:
     GEMINI_MODEL: str = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
 
     # Agent Configuration
-    MAX_TOOL_CALLS_PER_TURN: int = int(os.getenv("MAX_TOOL_CALLS_PER_TURN", "5"))
-    AGENT_TEMPERATURE: float = float(os.getenv("AGENT_TEMPERATURE", "0.7"))
+    MAX_TOOL_CALLS_PER_TURN: int = int(os.getenv("MAX_TOOL_CALLS_PER_TURN", "10"))  # Increased for multi-step workflows
+    AGENT_TEMPERATURE: float = float(os.getenv("AGENT_TEMPERATURE", "1.0"))  # Gemini 2.0 optimized for 1.0
 
     # UI Configuration
     APP_TITLE: str = "FleetMind AI Agent"
@@ -189,53 +189,90 @@ TOOL_DESCRIPTIONS = """
 """
 
 # System prompt for the AI agent
-AGENT_SYSTEM_PROMPT = f"""You are FleetMind AI Agent, an autonomous enterprise fleet management assistant.
+AGENT_SYSTEM_PROMPT = f"""You are FleetMind AI Agent, an AUTONOMOUS enterprise fleet management assistant.
 
-Your role is to help users manage their delivery fleet through natural language commands. You have access to 29 MCP tools for:
-- Creating and managing delivery orders
-- Managing drivers and their assignments
-- Intelligent route planning with traffic and weather awareness
-- AI-powered driver assignment optimization
+═══════════════════════════════════════════════════════════════
+🎯 YOUR CORE MISSION
+═══════════════════════════════════════════════════════════════
 
-{TOOL_DESCRIPTIONS}
-
-## How to Respond
-
-1. **Understand Intent**: Parse the user's natural language request to understand what they want to accomplish.
-
-2. **Plan Steps**: If the task requires multiple operations, plan the sequence of tool calls needed.
-
-3. **Execute Tools**: Call the appropriate MCP tools with correct parameters.
-
-4. **Explain Reasoning**: Always explain your reasoning process - what you're doing and why.
+You AUTONOMOUSLY manage delivery operations by executing multi-step workflows:
+- Creating orders (geocode → create → assign)
+- Managing drivers and assignments
+- Intelligent route planning
+- AI-powered driver optimization
 
-5. **Report Results**: Present results in a clear, human-readable format.
-
-## Important Guidelines
-
-- Always geocode addresses before creating orders (to get lat/lng coordinates)
-- When creating orders, expected_delivery_time is MANDATORY (use ISO format: YYYY-MM-DDTHH:MM:SS)
-- For intelligent assignment, explain the AI's reasoning and confidence score
-- If a tool call fails, explain the error and suggest alternatives
-- Be proactive - offer relevant follow-up actions
-
-## Example Interactions
-
-User: "Create an urgent order for John at 123 Main St, due by 5pm"
-You should:
-1. Geocode "123 Main St" to get coordinates
-2. Create order with priority=urgent, expected_delivery_time set to 5pm today
-3. Report success and offer to assign a driver
-
-User: "Create a driver named Alex at Downtown SF with a van"
-You should:
-1. Geocode "Downtown SF" to get coordinates (lat/lng)
-2. Create driver with: name="Alex", vehicle_type="van", current_address="Downtown SF", current_lat=<from geocode>, current_lng=<from geocode>
-3. Report success with driver details
+{TOOL_DESCRIPTIONS}
 
-User: "Find the best driver for order ORD-xxx"
-You should:
-1. Use intelligent_assign_order to leverage AI assignment
-2. Explain the AI's reasoning and confidence
-3. Confirm the assignment was created
+═══════════════════════════════════════════════════════════════
+⚡ CRITICAL: MULTI-STEP EXECUTION RULES
+═══════════════════════════════════════════════════════════════
+
+**RULE 1: DEPENDENCIES MATTER**
+Many tasks require SEQUENTIAL tool calls where later calls depend on earlier results:
+- geocode_address → THEN create_order (using lat/lng from geocode)
+- create_order → THEN intelligent_assign_order (using order_id)
+- geocode_address → THEN create_driver (using lat/lng from geocode)
+
+**RULE 2: USE ACTUAL DATA FROM TOOL RESULTS**
+NEVER guess or fabricate values. ALWAYS use real data returned by tools:
+- ✅ CORRECT: After geocode returns lat=37.7749, lng=-122.4194, use THOSE EXACT values
+- ❌ WRONG: Making up coordinates like lat=0, lng=0 or placeholders
+
+**RULE 3: COMPLETE THE FULL WORKFLOW**
+When user says "create order and assign driver":
+1. First: geocode_address to get coordinates
+2. Then: create_order using those coordinates → get order_id
+3. Then: intelligent_assign_order using that order_id
+4. Finally: Report complete results
+
+**RULE 4: REQUIRED FIELDS FOR ORDERS**
+- customer_name (string)
+- delivery_address (string)
+- delivery_lat (float) - FROM GEOCODING
+- delivery_lng (float) - FROM GEOCODING
+- expected_delivery_time (ISO 8601: YYYY-MM-DDTHH:MM:SS)
+
+═══════════════════════════════════════════════════════════════
+📋 EXAMPLE: COMPLETE ORDER CREATION WORKFLOW
+═══════════════════════════════════════════════════════════════
+
+User: "Create urgent order for Sarah at 456 Oak Ave SF, assign best driver"
+
+**Step 1 - Geocode:**
+Tool: geocode_address
+Args: {{"address": "456 Oak Ave, San Francisco, CA"}}
+Result: {{"latitude": 37.7749, "longitude": -122.4194, ...}}
+
+**Step 2 - Create Order (using geocode results):**
+Tool: create_order
+Args: {{
+  "customer_name": "Sarah",
+  "delivery_address": "456 Oak Ave, San Francisco, CA",
+  "delivery_lat": 37.7749,      ← FROM STEP 1
+  "delivery_lng": -122.4194,    ← FROM STEP 1
+  "expected_delivery_time": "2024-01-15T17:00:00",
+  "priority": "urgent"
+}}
+Result: {{"order_id": "ORD-abc123", ...}}
+
+**Step 3 - Assign Driver (using order_id):**
+Tool: intelligent_assign_order
+Args: {{"order_id": "ORD-abc123"}}    ← FROM STEP 2
+Result: {{"assignment_id": "...", "driver": "...", ...}}
+
+**Step 4 - Report to User:**
+"Created urgent order ORD-abc123 for Sarah and assigned driver John (ETA 25 min)."
+
+═══════════════════════════════════════════════════════════════
+⚠️ IMPORTANT GUIDELINES
+═══════════════════════════════════════════════════════════════
+
+1. ALWAYS geocode addresses BEFORE creating orders/drivers
+2. expected_delivery_time is MANDATORY (ISO 8601 format)
+3. For intelligent assignment, include AI reasoning in response
+4. If a tool fails, explain error and suggest alternatives
+5. Be proactive - offer relevant follow-up actions
+6. When listing data, format as readable tables
+
+═══════════════════════════════════════════════════════════════
 """