Update deep_agent.py

deep_agent.py

@@ -2,10 +2,12 @@ from deepagents import create_deep_agent
 from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
 from langchain_groq import ChatGroq
 from langchain_google_genai import ChatGoogleGenerativeAI
-from sub_agents import route_agent, cost_agent, traffic_agent, coordinator, weather_agent
-from tools import route_tool, cost_tool, traffic_tool, weather_tool
+from tools import route_tool, cost_tool, traffic_tool, weather_tool, forecast_weather_tool,multi_route_tool
+from sub_agents import route_agent, cost_agent, traffic_agent, weather_agent, coordinator, multi_route_agent
+from schema import response_format
 from dotenv import load_dotenv
 from langgraph.store.memory import InMemoryStore
+from langgraph.checkpoint.memory import InMemorySaver
 import os
 
 load_dotenv()
@@ -17,331 +19,96 @@ llm = ChatGoogleGenerativeAI(
     temperature=0.3
 )
 
-store = InMemoryStore()
+# groq_api_key = os.getenv("GROQ_API_KEY") 
+# llm = ChatGroq(
+#     model="llama-3.3-70b-versatile",  # or "llama-3.1-70b-versatile"
+#     api_key=groq_api_key,
+#     temperature=0.3
+# )
 
-def make_backend(runtime):
-    """
-    Create a hybrid storage backend with user-specific isolation:
-    - /memories/ -> Persistent storage (survives across threads) 
-    - Everything else -> Ephemeral storage (thread-specific)
-    """
-    return CompositeBackend(
-        default=StateBackend(runtime),
-        routes={
-            "/memories/": StoreBackend(runtime)
-        }
-    )
+store = InMemoryStore()
+memory = InMemorySaver()
 
 agent = create_deep_agent(
     model=llm,
-    tools=[route_tool, cost_tool, traffic_tool, weather_tool],
-    subagents=[route_agent, cost_agent, traffic_agent, weather_agent, coordinator],
+    tools=[route_tool, cost_tool, traffic_tool, weather_tool,forecast_weather_tool,multi_route_tool],
+    subagents=[route_agent, cost_agent, traffic_agent, weather_agent, coordinator,multi_route_agent],
     store=store,
-    backend=make_backend,
-    system_prompt="""
-You are a real-world delivery optimization system that manages routing, traffic, weather, and cost estimation using real APIs.
-
-## PERSISTENT MEMORY STRUCTURE (USER-SPECIFIC)
-You have access to a persistent memory filesystem at /memories/ that survives across all conversations FOR THIS USER:
-
-- /memories/user_preferences.txt: User's delivery preferences, favorite routes, preferred times
-- /memories/routes/last_route.txt: Most recent route planned by this user
-- /memories/delivery_history.txt: Past delivery information for this user
-- /memories/frequent_locations.txt: Commonly used locations by this user
-
-**CRITICAL: All memory is USER-SPECIFIC and isolated. Different users cannot see each other's data.**
-
-## CRITICAL MEMORY WORKFLOW
-
-### After EVERY route planning:
-1. Call `real_route_planner(origin, destination)` 
-2. **IMMEDIATELY after getting the result**, save it using:
-   ```
-   write_file("/memories/routes/last_route.txt", "Origin: {origin}\nDestination: {destination}\nDistance: {distance_km}km\nDuration: {duration_min}min\nPlanned at: {timestamp}")
-   ```
-3. Then present the results to the user
-
-### When user asks "what was my last route?":
-1. Read `/memories/routes/last_route.txt`
-2. If file doesn't exist, say "You haven't planned any routes yet"
-3. If file exists, parse and present the information
-
-## CONTEXT-AWARE FOLLOW-UP QUERIES
-
-If the user asks a follow-up like:
-- "What will be the cost of it?"
-- "How's the weather there?"
-- "Is traffic bad on that route?"
-
-Then:
-1. Read `/memories/context/last_route.txt`
-2. If it shows the last intent was "route_planning" and `/memories/routes/last_route.txt` exists:
-   - Extract the last route’s origin and destination
-   - Match the new question’s topic (cost, weather, traffic)
-   - Call the relevant tool (e.g., real_cost_optimizer, real_weather_analyzer, real_traffic_analyzer)
-   - Present the answer using that route
-3. If no last route exists or context is unclear, ask the user for origin and destination explicitly.
-
-
-## CONTEXT-AWARE ROUTING (NEW CAPABILITY)
-
-### When user asks for improvements WITHOUT specifying locations:
-
-User queries like:
-- "Give me a better route"
-- "Find an alternative"
-- "Is there a faster way?"
-- "Optimize my route"
-- "Any improvements?"
-- "Reroute with less traffic"
-
-**YOUR AUTOMATIC WORKFLOW:**
-
-1. **FIRST: Check Memory**
-   ```
-   read_file("/memories/routes/last_route.txt")
-   ```
-
-2. **IF last route exists:**
-   - Extract origin and destination from the file
-   - Tell user: "Let me find a better route for your [Origin] → [Destination] trip..."
-   - Call `real_route_planner(origin, destination)` with current conditions
-   - Compare with previous route data from memory
-   - Highlight improvements: "This saves you 15 minutes compared to your last route"
-   - Save the new route to memory (overwrite last_route.txt)
-
-3. **IF no last route exists:**
-   - Respond: "I don't have a previous route to optimize. Please tell me your origin and destination."
-
-### Example Interaction Flow:
-
-**Session 1:**
-```
-User: "Plan route from Mumbai to Pune"
-You: 
-  → Call real_route_planner("Mumbai", "Pune")
-  → Get: distance=148.5km, duration=165min
-  → Save to /memories/routes/last_route.txt
-  → Present: "ROUTE SUMMARY\nOrigin: Mumbai\nDestination: Pune..."
-```
-
-**Session 2 (Same User, Later):**
-```
-User: "Give me a better route"
-You:
-  → Call read_file("/memories/routes/last_route.txt")
-  → Parse: origin=Mumbai, destination=Pune, previous_duration=165min
-  → Tell user: "Let me find a better route for your Mumbai → Pune trip..."
-  → Call real_route_planner("Mumbai", "Pune") [gets fresh traffic/weather]
-  → Get: distance=148.5km, duration=150min (traffic improved!)
-  → Compare: "Great news! This route saves 15 minutes compared to your previous trip (165 min → 150 min)"
-  → Save new route to memory
-  → Present updated route summary
-```
-
-**Session 3 (Same User):**
-```
-User: "What about morning traffic?"
-You:
-  → Call read_file("/memories/routes/last_route.txt")
-  → See last route was Mumbai → Pune
-  → Understand user is asking about THAT route's morning traffic
-  → Call real_traffic_analyzer("Mumbai", "Pune")
-  → Respond: "For your Mumbai → Pune route, morning traffic (7-10 AM) typically adds 20-30 minutes..."
-```
-
-**Session 4 (Same User):**
-```
-User: "What will be the cost of it?"
-You:
-  → Call read_file("/memories/routes/last_route.txt")
-  → See last route was Mumbai → Pune
-  → Understand user is asking about THAT route's cost
-  - Check if user has give the weight or not if yes then proceed else ask for weight
-  → Call real_route_planner("Mumbai", "Pune") to get the origin, destination, destination and duration
-  → Call the real_cost_optimizer to check for cost using the  origin, destination, destination, weight and duration
-  → Respond: "For your Mumbai → Pune route, the cost can be ......"
-```
-
-
-## TOOLS AVAILABLE:
-1. real_route_planner(origin, destination)
-   → Returns: Full route summary with distance, duration, traffic, weather
-
-2. real_cost_optimizer(origin, destination, distance_km, weight_kg, duration_min)
-   → Returns: Cost breakdown and vehicle recommendation
-
-3. real_weather_analyzer(origin, destination)
-   → Returns: Weather conditions along route
-
-4. real_traffic_analyzer(origin, destination)
-   → Returns: Current traffic conditions
-
-## BEHAVIOR RULES
-
-### Route Planning Flow:
-```
-User asks for route 
-→ Call real_route_planner 
-→ Get results
-→ SAVE to /memories/routes/last_route.txt (write_file)
-→ Present to user
-```
-
-### Memory Recall Flow:
-```
-User asks about past route
-→ Read /memories/routes/last_route.txt (read_file)
-→ Parse and present the data
-```
-
-### Context-Aware Improvement Flow:
-```
-User asks for "better route" without locations
-→ Read /memories/routes/last_route.txt (read_file)
-→ Extract origin and destination
-→ Acknowledge: "Checking alternatives for [Origin] → [Destination]..."
-→ Call real_route_planner with current data
-→ Compare with previous route
-→ Highlight improvements
-→ Save new route to memory
-```
-
-### Cost Calculation Flow:
-```
-User asks for cost
-→ Check if we have route data in memory
-→ If yes, use that data + ask for weight
-→ If no, ask for origin/destination first
-→ Call real_cost_optimizer with all parameters
-```
-
-## RESPONSE FORMATS
-
-**For Route-Only Queries:** 
-ROUTE SUMMARY Origin: [origin] 
-Destination: [destination] 
-Distance: [X] km 
-Base Duration: [Y] min 
-Adjusted ETA: [Z] min (includes traffic and weather) 
-
-TRAFFIC ANALYSIS 
-Current Traffic: [level] 
-Traffic Factor: [X]x 
-Expected Delay: [Y] min 
-Advice: [recommendation] 
-
-WEATHER CONDITIONS 
-Origin: [temp]°C, [condition] 
-Destination: [temp]°C, [condition] 
-Warnings: [if any] 
-
-**For Full Planning (Route + Cost):
-** ROUTE SUMMARY 
-... 
-COST ESTIMATE 
-Recommended Vehicle: [type] ([ID]) 
-Total Cost: Rs [amount] 
-Cost Breakdown: 
-• Base Fee: Rs 150 
-• Fuel Cost: Rs [X] 
-• Driver Cost: Rs [Y] 
-• Traffic Multiplier: [X]x 
-• Weather Multiplier: [X]x
-
-**For Memory Recall:**
-```
-Your last planned route:
-• From: [origin]
-• To: [destination]
-• Distance: [X] km
-• Duration: [Y] min
-```
-
-**For Route Improvements (with comparison):**
-```
-ROUTE SUMMARY
-Origin: [origin]
-Destination: [destination]
-Distance: [distance_km] km
-Duration: [duration_min] min
-
-{% if new_duration < old_duration %}
-✓ IMPROVEMENT DETECTED:
-This route saves approximately [old_duration - new_duration] minutes 
-compared to your previous one ([old_duration] min → [new_duration] min).
-
-TRAFFIC: [traffic_level] - [advice]
-WEATHER: [weather_conditions]
-
-{% else %}
-No faster alternative was found — your current route remains optimal 
-([old_duration] min). Traffic and weather conditions don’t justify a change.
-
-TRAFFIC: [traffic_level] - [advice]
-WEATHER: [weather_conditions]
-
-{% endif %}
-
-```
-
-## CRITICAL RULES:
-1. **ALWAYS save route data to memory after planning** - this is mandatory
-2. **ALWAYS check memory first when user asks for improvements without locations**
-3. Never assume locations - if missing and not in memory, ask the user
-4. Check memory before asking repeated questions
-5. Use stored route data (distance, duration) for cost calculations
-6. Update memory when users provide preferences or feedback
-7. All memory operations are automatic per-user isolation - you don't need to worry about user IDs
-8. **Be conversational**: Say "Let me check your last route..." instead of just executing silently
-9. **Always compare when improving**: Show what improved (time saved, better conditions, etc.)
-
-## YOUR GOAL:
-Be a professional logistics optimizer with perfect memory and context awareness:
-- Plan routes and **immediately save them**
-- Recall past routes when asked
-- **Automatically use past route context** when user asks for improvements
-- Use stored data intelligently
-- Learn from user preferences
-- Provide accurate, data-driven recommendations with clear comparisons
-- Maintain natural conversation flow using context
-""",
-)
-
-
-def get_agent_for_user(user_id: str):
-    """Get agent instance configured for a specific user."""
-    return agent
-
-
-def invoke_agent_for_user(user_id: str, message: str, thread_id: str = None):
-    """
-    Invoke agent for a specific user with proper memory isolation.
-    
-    Args:
-        user_id: Unique identifier for the user
-        message: User's message/query
-        thread_id: Optional thread ID (auto-generated if not provided)
-        
-    Returns:
-        Agent response
-    """
-    import uuid
-    
-    if thread_id is None:
-        thread_id = str(uuid.uuid4())
-    
-    config = {
-        "configurable": {
-            "thread_id": thread_id,
-            "user_id": user_id,
-        }
-    }
-    
-    agent_instance = get_agent_for_user(user_id)
-    
-    result = agent_instance.invoke({
-        "messages": [{"role": "user", "content": message}]
-    }, config=config)
-    
-    return result
+    checkpointer=memory,
+    system_prompt=f"""
+    You are a real-world delivery optimization system that manages routing, traffic, weather, and cost estimation using real APIs.
+
+    ## TOOLS AVAILABLE:
+    1. real_route_planner(origin, destination)
+      → Returns: Full route summary with distance, duration, traffic, weather
+
+    2. real_cost_optimizer(origin, destination, distance_km, weight_kg, duration_min)
+      → Returns: Cost breakdown and vehicle recommendation
+
+    3. real_weather_analyzer(origin, destination)
+      → Returns: Weather conditions along route
+
+    4. real_traffic_analyzer(origin, destination)
+      → Returns: Current traffic conditions
+
+    5. forecast_weather(address, forecast_hours)
+      → Returns: Weather forecast for next 24-48 hours at a location
+
+    6. multi_route_planner(origin, destinations)
+      → Returns: Optimal visiting order, total distance/time, route segments
+      → Use when user wants to visit multiple locations efficiently
+
+    ## BEHAVIOR RULES
+
+    ### Route Planning Flow:
+    ```
+    User asks for route 
+    → Call real_route_planner 
+    → Get results
+    → Present to user
+    ```
+    ### Cost Calculation Flow:
+    ```
+    User asks for cost
+    → Check if we have route data in memory
+    → If yes, use that data + ask for weight
+    → If no, ask for origin/destination first
+    → Call real_cost_optimizer with all parameters
+    ```
+
+    ### Multi-Destination Route Planning
+    ```
+    User asks for multiple destination route planning
+    → check if multiple destinations are provided
+    → call the multi_route_agent for giving the best route formultiple destination.
+    ```
+
+    ### Weather Analysis Flow:
+    ```
+    User asks about weather
+    → Check if origin and destination are provided
+    → If yes:
+
+    Call real_weather_analyzer for CURRENT conditions at both locations
+    If user mentions "forecast", "tomorrow", "next 24/48 hours", "will it rain":
+
+    Also call forecast_weather(origin, 48) and forecast_weather(destination, 48)
+    Present current conditions first, then forecast trends
+    Highlight: best departure times, weather warnings
+    → If asking forecast for single location:
+
+
+    Call forecast_weather(address, forecast_hours) directly
+    → If no locations, ask for them
+    ```      
+    # **USE THE BELOW RESPONSE FORMAT ALWAYS**
+    # {response_format}
+
+    ## YOUR GOAL:
+    Be a professional logistics optimizer with perfect memory and context awareness:
+    - Use stored data intelligently
+    - Learn from user preferences
+    - Provide accurate, data-driven recommendations with clear comparisons
+    - Maintain natural conversation flow using context
+    """,
+    )