fleshing out raven and magpie, and tweaking their toolsets, and giving everyone memory access and making three kinds of memory: paper, observation, and trend.

quick_check.py

@@ -1,4 +1,4 @@
-from src.cluas_mcp.common.memory import AgentMemory
+from src.cluas_mcp.common.paper_memory import AgentMemory
 
 # scored search
 memory = AgentMemory()

src/characters/corvus.py

@@ -7,7 +7,8 @@ from typing import Optional, List, Dict
 from dotenv import load_dotenv
 from groq import Groq
 from src.cluas_mcp.academic.academic_search_entrypoint import academic_search
-from src.cluas_mcp.common.memory import AgentMemory
+from src.cluas_mcp.common.paper_memory import PaperMemory
+from src.cluas_mcp.common.observation_memory import ObservationMemory
 
 load_dotenv()
 logger = logging.getLogger(__name__)
@@ -18,7 +19,8 @@ class Corvus:
     def __init__(self, use_groq=True, location="Glasgow, Scotland"):
         self.name = "Corvus"
         self.use_groq = use_groq
-        self.memory = AgentMemory()
+        self.paper_memory = PaperMemory() 
+        self.observation_memory = ObservationMemory(location=location)
 
          
         if use_groq:

src/characters/crow.py

@@ -3,16 +3,21 @@ import json
 import asyncio
 import requests
 import logging
-from typing import Optional, List, Dict
+from datetime import datetime, UTC
+from typing import Optional, List, Dict, Any
 from dotenv import load_dotenv
 from groq import Groq
 from src.cluas_mcp.observation.observation_entrypoint import (
     get_bird_sightings, 
     get_weather_patterns, 
     get_air_quality, 
-    get_moon_phase,  # note: matches entrypoint function name
-    get_sun_times
+    get_moon_phase,
+    get_sun_times,
+    analyze_temporal_patterns
 )
+from src.cluas_mcp.common.observation_memory import ObservationMemory
+from src.cluas_mcp.common.paper_memory import PaperMemory
+
 
 load_dotenv()
 logger = logging.getLogger(__name__)
@@ -24,6 +29,8 @@ class Crow:
         self.name = "Crow"
         self.use_groq = use_groq
         self.location = location  # crow's home location
+        self.observation_memory = ObservationMemory()
+        self.paper_memory = PaperMemory()
         
         # map tool names to functions for dispatch
         self.tool_functions = {
@@ -32,6 +39,7 @@ class Crow:
             "get_air_quality": get_air_quality,
             "get_moon_phase": get_moon_phase,
             "get_sun_times": get_sun_times,
+            "analyze_temporal_patterns": analyze_temporal_patterns
         }
         
         if use_groq:
@@ -44,7 +52,7 @@ class Crow:
             self.model = "llama3.1:8b"
         
     def get_system_prompt(self) -> str:
-        return f"""You are Crow, a calm and observant nature watcher based in {self.location}.
+        base_prompt = f"""You are Crow, a calm and observant nature watcher based in {self.location}.
 
 TEMPERAMENT: Phlegmatic - calm, observant, methodical, detail-oriented, patient
 ROLE: Observer and pattern analyzer in a corvid enthusiast group chat
@@ -69,6 +77,32 @@ TOOLS AVAILABLE:
 - get_sun_times: Get sunrise/sunset times for a location
 
 When discussing weather, birds, air quality, or natural patterns, use your tools to get real data!"""
+        return base_prompt + self._build_recent_observation_context()
+
+    def _build_recent_observation_context(self) -> str:
+        """Summarize recent observations for extra context in the system prompt."""
+        try:
+            recent = self.memory.get_recent(days=3)
+        except Exception as exc:
+            logger.warning("Unable to load recent observations: %s", exc)
+            return ""
+
+        if not recent:
+            return ""
+
+        counts: Dict[str, int] = {}
+        for obs in recent:
+            obs_type = obs.get("type", "observation")
+            counts[obs_type] = counts.get(obs_type, 0) + 1
+
+        summary_lines = [
+            "\n\nRECENT OBSERVATIONS:",
+            f"You have logged {len(recent)} observations in the last 3 days:"
+        ]
+        for obs_type, count in sorted(counts.items()):
+            summary_lines.append(f"- {count} × {obs_type}")
+
+        return "\n".join(summary_lines) + "\n"
 
     async def respond(self, 
                      message: str,
@@ -215,6 +249,9 @@ When discussing weather, birds, air quality, or natural patterns, use your tools
                 tool_func = self.tool_functions[tool_name]
                 tool_result = await loop.run_in_executor(None, lambda: tool_func(**args))
                 
+                # persist what Crow observed for later pattern analysis
+                self._record_observation(tool_name, args, tool_result, message)
+                
                 # format results for LLM
                 formatted_result = self._format_observation_for_llm(tool_name, tool_result)
                 
@@ -300,6 +337,91 @@ When discussing weather, birds, air quality, or natural patterns, use your tools
         
         # fallback: return JSON summary
         return json.dumps(result, indent=2)[:500]
+
+    def _record_observation(self, tool_name: str, args: Dict[str, Any], result: Dict[str, Any], user_message: str) -> None:
+        """Persist the tool result to Crow's observation memory."""
+        try:
+            location = args.get("location") or args.get("city") or self.location
+            obs_type = tool_name.replace("get_", "")
+            tags = [obs_type]
+
+            hour = datetime.now(UTC).hour
+            if 5 <= hour < 12:
+                tags.append("morning")
+            elif 12 <= hour < 17:
+                tags.append("afternoon")
+            elif 17 <= hour < 21:
+                tags.append("evening")
+            else:
+                tags.append("night")
+
+            conditions = self._derive_conditions(tool_name, result)
+            notes = f"Triggered by: {user_message[:120]}"
+
+            self.memory.add_observation(
+                obs_type=obs_type,
+                location=location,
+                data=result,
+                conditions=conditions,
+                tags=tags,
+                notes=notes
+            )
+        except Exception as exc:
+            logger.warning("Failed to store %s observation: %s", tool_name, exc)
+
+    def _derive_conditions(self, tool_name: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract comparable condition data from observation payloads."""
+        if tool_name == "get_weather_patterns":
+            patterns = data.get("patterns", {})
+            return {
+                "weather": patterns.get("conditions") or patterns.get("description"),
+                "temperature": patterns.get("average_temperature"),
+                "humidity": patterns.get("humidity"),
+                "wind_speed": patterns.get("wind_speed"),
+            }
+
+        if tool_name == "get_air_quality":
+            readings: List[float] = []
+            for location in data.get("locations", []):
+                measurements = location.get("measurements") or []
+                if measurements:
+                    latest = measurements[0]
+                    value = latest.get("value")
+                    if isinstance(value, (int, float)):
+                        readings.append(float(value))
+            avg_reading = round(sum(readings) / len(readings), 2) if readings else None
+            return {
+                "air_quality": avg_reading,
+                "parameter": data.get("parameter"),
+            }
+
+        if tool_name == "get_bird_sightings":
+            return {
+                "bird_count": data.get("count"),
+            }
+
+        if tool_name == "get_moon_phase":
+            return {
+                "moon_phase": data.get("phase"),
+                "illumination": data.get("illumination"),
+            }
+
+        if tool_name == "get_sun_times":
+            return {
+                "sunrise": data.get("sunrise"),
+                "sunset": data.get("sunset"),
+            }
+
+        return {}
+
+
+    def recall_observations(self, obs_type: str, days: int = 7) -> List[Dict]:
+        """Fetch recent observations of a particular type."""
+        return self.memory.search_observations(obs_type=obs_type, days=days)
+
+    def clear_memory(self) -> None:
+        """Reset Crow's observation memory (useful for tests)."""
+        self.memory.clear_all()
     
     def _respond_ollama(self, message: str, history: Optional[List[Dict]] = None) -> str:
         """Use Ollama (no tool support, conversational only)."""

src/characters/magpie.py

@@ -4,7 +4,11 @@ import asyncio
 from typing import Optional, List, Dict
 from dotenv import load_dotenv
 from groq import Groq
-from src.cluas_mcp.web.web_search_entrypoint import search_web, find_trending_topics, get_quick_facts
+from src.cluas_mcp.web.web_search import search_web, find_trending_topics, get_quick_facts
+
+from src.cluas_mcp.common.paper_memory import PaperMemory
+from src.cluas_mcp.common.observation_memory import ObservationMemory
+
 
 load_dotenv()
 
@@ -12,7 +16,9 @@ class Magpie:
     def __init__(self, use_groq=True, location="Brooklyn, NY"):
         self.name = "Magpie"
         self.use_groq = use_groq
-        self.tools = ["search_web", "find_trending_topics", "get_quick_facts"]
+        self.tools = ["search_web", "find_trending_topics"]
+        self.paper_memory = PaperMemory()
+        self.observation_memory = ObservationMemory(location=location)
         
         if use_groq:
             api_key = os.getenv("GROQ_API_KEY")

src/characters/raven.py

@@ -1,18 +1,30 @@
 import os
 import json
 import asyncio
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Any
 from dotenv import load_dotenv
 from groq import Groq
 from src.cluas_mcp.news.news_search import search_news
+from src.cluas_mcp.web.web_search import search_web
+from src.cluas_mcp.web.trending import fetch_trends
+from src.cluas_mcp.common.paper_memory import PaperMemory
+from src.cluas_mcp.common.observation_memory import ObservationMemory
 
 load_dotenv()
 
 class Raven:
     def __init__(self, use_groq=True, location="Seattle, WA"):
         self.name = "Raven"
+        self.location = location
         self.use_groq = use_groq
-        self.tools = ["search_news", "get_environmental_data", "verify_claim"]
+        self.tools = ["search_news", "search_web", "fetch_trends"]
+        self.paper_memory = PaperMemory()
+        self.observation_memory = ObservationMemory(location=location)
+        self.tool_functions = {
+            "search_news": search_news,
+            "search_web": search_web,
+            "fetch_trends": fetch_trends,
+        }
         
         if use_groq:
             api_key = os.getenv("GROQ_API_KEY")
@@ -42,16 +54,206 @@ You're in a group chat, but you're not afraid to speak your mind.
 
 TOOLS AVAILABLE:
 - search_news: Search for current news articles
-- get_environmental_data: Get environmental data and statistics
-- verify_claim: Verify the truthfulness of claims
+- search_web: Search the web for information
+- fetch_trends: Get trending topics in news
 
 When you need to verify information or find current news, use your tools!"""
 
     async def respond(self, 
                      message: str,
                      conversation_history: Optional[List[Dict]] = None) -> str:
-        """Generate a response. Stub implementation for MVP."""
-        # For MVP, return a simple mock response
-        # TODO: Implement full Groq integration with tool calling
-        return "That's an important point. Let me verify that and check the latest news on this."
+        """Generate a response."""
+        if self.use_groq:
+            return await self._respond_groq(message, conversation_history)
+        return self._respond_ollama(message, conversation_history)
+
+    async def _respond_groq(self, message: str, history: Optional[List[Dict]] = None) -> str:
+        """Use Groq with tool calling for Raven's investigative workflow."""
+        messages = [{"role": "system", "content": self.get_system_prompt()}]
+
+        if history:
+            messages.extend(history[-5:])
+
+        messages.append({"role": "user", "content": message})
+
+        tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "search_news",
+                    "description": "Search for current news articles and reports",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "Topic or question to search in news outlets"
+                            },
+                            "max_results": {
+                                "type": "integer",
+                                "description": "Maximum number of articles to return (default 5)"
+                            }
+                        },
+                        "required": ["query"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "search_web",
+                    "description": "Search the broader web for claims, sources, and facts",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "Search query for the web"
+                            }
+                        },
+                        "required": ["query"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "fetch_trends",
+                    "description": "Fetch trending topics for a category",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "category": {
+                                "type": "string",
+                                "description": "Trend category (e.g., 'news', 'climate', 'tech')"
+                            }
+                        },
+                        "required": ["category"]
+                    }
+                }
+            }
+        ]
+
+        first_response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            tools=tools,
+            tool_choice="auto",
+            temperature=0.8,
+            max_tokens=150
+        )
+
+        choice = first_response.choices[0]
+
+        if choice.finish_reason == "tool_calls" and choice.message.tool_calls:
+            tool_call = choice.message.tool_calls[0]
+            tool_name = tool_call.function.name
+
+            if tool_name in self.tool_functions:
+                args = json.loads(tool_call.function.arguments)
+                loop = asyncio.get_event_loop()
+                tool_func = self.tool_functions[tool_name]
+                tool_result = await loop.run_in_executor(None, lambda: tool_func(**args))
+                
+                formatted = self._format_tool_result(tool_name, tool_result)
+
+                messages.append({
+                    "role": "assistant",
+                    "content": None,
+                    "tool_calls": [{
+                        "id": tool_call.id,
+                        "type": "function",
+                        "function": {
+                            "name": tool_name,
+                            "arguments": tool_call.function.arguments
+                        }
+                    }]
+                })
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": formatted
+                })
+
+                second_response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    temperature=0.8,
+                    max_tokens=200
+                )
+                return second_response.choices[0].message.content.strip()
+
+        return choice.message.content.strip()
+
+    def _format_tool_result(self, tool_name: str, result: Dict[str, Any]) -> str:
+        if tool_name == "search_news":
+            return self._format_news_for_llm(result)
+        if tool_name == "search_web":
+            return self._format_web_search_for_llm(result)
+        if tool_name == "fetch_trends":
+            return self._format_trends_for_llm(result)
+        return json.dumps(result, indent=2)[:500]
+
+    def _format_news_for_llm(self, result: Dict[str, Any]) -> str:
+        articles = result.get("articles") or result.get("results") or []
+        if not articles:
+            return "No news articles found."
+
+        lines = ["News search results:"]
+        for idx, article in enumerate(articles[:5], start=1):
+            title = article.get("title", "Untitled")
+            source = article.get("source", "Unknown source")
+            summary = article.get("summary") or article.get("description") or ""
+            lines.append(f"{idx}. {title} — {source}. {summary[:160]}...")
+        return "\n".join(lines)
+
+    def _format_web_search_for_llm(self, result: Dict[str, Any]) -> str:
+        items = result.get("results") or result.get("items") or []
+        if not items:
+            return "No web results found."
+
+        lines = ["Web search results:"]
+        for idx, item in enumerate(items[:5], start=1):
+            title = item.get("title", "Untitled")
+            url = item.get("url") or item.get("link", "")
+            snippet = item.get("snippet") or item.get("description") or ""
+            lines.append(f"{idx}. {title} ({url}) — {snippet[:160]}...")
+        return "\n".join(lines)
+
+    def _format_trends_for_llm(self, result: Dict[str, Any]) -> str:
+        trends = result.get("trends") or result.get("topics") or []
+        category = result.get("category", "general")
+        if not trends:
+            return f"No trending topics found for {category}."
+
+        lines = [f"Trending topics for {category}:"]
+        for idx, topic in enumerate(trends[:5], start=1):
+            name = topic.get("name") or topic.get("title") or "Unnamed trend"
+            detail = topic.get("description") or topic.get("snippet") or ""
+            lines.append(f"{idx}. {name} — {detail[:160]}...")
+        return "\n".join(lines)
+
+    def _respond_ollama(self, message: str, history: Optional[List[Dict]] = None) -> str:
+        """Placeholder for local inference without tool calls."""
+        prompt = self._build_prompt(message, history)
+        return (
+            "I'm double-checking that with my own notes. "
+            "Hang tight while I look for corroborating sources."
+        )
+
+    def _build_prompt(self, message: str, history: Optional[List[Dict]] = None) -> str:
+        """Construct a lightweight conversation transcript for local models."""
+        if not history:
+            return f"User: {message}\n\nRaven:"
+        transcript: List[str] = []
+        for item in history[-5:]:
+            role = item.get("role")
+            content = item.get("content", "")
+            if role == "user":
+                transcript.append(f"User: {content}")
+            elif role == "assistant":
+                transcript.append(f"Raven: {content}")
+        transcript.append(f"User: {message}")
+        transcript.append("Raven:")
+        return "\n\n".join(transcript)
 

src/cluas_mcp/observation/observation_entrypoint.py

@@ -5,6 +5,7 @@ from src.cluas_mcp.observation.weather import fetch_weather_patterns
 from src.cluas_mcp.observation.airquality import fetch_air_quality
 from src.cluas_mcp.observation.moon_phase import fetch_moon_phase
 from src.cluas_mcp.observation.sunrise_sunset import fetch_sunrise_sunset
+from src.cluas_mcp.common.observation_memory import ObservationMemory
 
 logger = logging.getLogger(__name__)
 
@@ -90,6 +91,10 @@ def get_sun_times(location: str, date: Optional[str] = None) -> dict:
     logger.info(f"Getting sun times for {location}, date: {date}")
     return fetch_sunrise_sunset(location, date)
 
+def analyze_temporal_patterns(obs_type: str, location: Optional[str] = None, days: int = 30) -> dict:
+    """Analyze patterns from stored observations."""
+    memory = ObservationMemory(location=location)
+    return memory.analyze_patterns(obs_type, location, days)
 
 # def analyze_temporal_patterns(data_type: str, location: str = "global") -> dict:
 #     """

src/cluas_mcp/server.py

@@ -6,7 +6,7 @@ from mcp.server.stdio import stdio_server
 from mcp.types import Tool, TextContent
 
 from src.cluas_mcp.academic.academic_search_entrypoint import academic_search
-from src.cluas_mcp.web.web_search_entrypoint import search_web, find_trending_topics, get_quick_facts
+from src.cluas_mcp.web.web_search import search_web, find_trending_topics, get_quick_facts
 from src.cluas_mcp.news.news_search_entrypoint import search_news, get_environmental_data, verify_claim
 from src.cluas_mcp.observation.observation_entrypoint import get_bird_sightings, get_weather_patterns, analyze_temporal_patterns
 

src/cluas_mcp/web/trending.py

@@ -4,7 +4,7 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-def find_trending_topics(category: str = "general") -> dict:
+def fetch_trends(category: str = "general") -> dict:
     """
     Get trending topics with cascading fallbacks:
     1. Try Google Trends (pytrends) - no API key needed

src/cluas_mcp/web/{web_search_entrypoint.py → web_search.py}

@@ -74,7 +74,7 @@ def _mock_search_web(query: str) -> dict:
         "total_results": 2
     }
 
-def find_trending_topics(category: str = "general") -> dict:
+def fetch_trending(category: str = "general") -> dict:
     """
     Find trending topics in a given category.