Implement my agent

README.md

@@ -16,13 +16,26 @@ license: mit
 
 This is my submission for the Text Adventure Agent assignment. My agent uses the ReAct pattern to play text adventure games via MCP.
 
+Based on the example gave I improved some features. I added a long term memory in order to keep in mind long term objectives, I added memory of actions done in the current map to not repeat wrong directions, I added a memory on last 10 rooms visited and the path done in order to not being stucked in forest or to go back in interesting rooms. I also changed the way of actualisation of current rooms.
+
 ## Approach
 
-<!-- Describe your approach here -->
+This agent uses the following pattern:
+1. **Thought**: Reason about the current situation
+2. **Long Term Memory**: Long term memory in order to follow long term objectives like finding a lamp or going back to a room.
+2. **Tool**: Choose and call an MCP tool
+3. **Observation**: Process the result
+
+I kept the tools from the baseline and then add get_current_map() for the history of the current map and get_last_10_rooms for the last 10 rooms explored. Initially I let the choice to the the LLM to use it but regarding to the importance of those compared to the number of token I choosed to automatically use it at each step.
+
+The prompt is then composed of :
 
-- What strategy does your agent use?
-- What tools did you implement in your MCP server?
-- Any interesting techniques or optimizations?
+-current score
+-long term memory
+-recent actions
+-last 10 rooms explored
+-Current location and past actions already explored in this location.
+-Observation
 
 ## Files
 

agent.py

@@ -1,26 +1,8 @@
 """
-Student Agent for Text Adventure Games
+Example: MCP ReAct Agent
 
-This is your submission file. Implement the StudentAgent class to play
-text adventure games using the MCP server you also implement.
-
-Your agent should:
-1. Connect to the MCP server via the provided client
-2. Use the ReAct pattern (Thought -> Action -> Observation)
-3. Call MCP tools to interact with the game
-4. Maximize the game score within the step limit
-
-Required method:
-    async def run(self, client, game, max_steps, seed, verbose) -> RunResult
-
-The 'client' is a FastMCP Client already connected to your MCP server.
-Use it to call tools like: await client.call_tool("play_action", {"action": "look"})
-
-Tips:
-- Start by looking around and understanding your environment
-- Keep track of visited locations to avoid loops
-- Pick up useful items (lamp, sword, etc.)
-- The seed parameter should be used to set your LLM's seed for reproducibility
+A complete ReAct agent that uses MCP tools to play text adventure games.
+This is a working example students can learn from.
 """
 
 import json
@@ -32,83 +14,36 @@ from typing import Optional
 from dotenv import load_dotenv
 from huggingface_hub import InferenceClient
 
-# Load environment variables
 load_dotenv()
 
-# Set USE_LOCAL_MODEL=1 in your .env to use a locally downloaded model
-USE_LOCAL_MODEL = os.getenv("USE_LOCAL_MODEL", "0").strip() in ("1", "true", "yes")
-LOCAL_MODEL_ID = os.getenv("LOCAL_MODEL_ID", "Qwen/Qwen2.5-3B-Instruct")
-
 # =============================================================================
 # LLM Configuration - DO NOT MODIFY
 # =============================================================================
 
-# Model to use (fixed for fair evaluation)
 LLM_MODEL = "Qwen/Qwen2.5-72B-Instruct"
 
-# Initialize the LLM client based on mode
-_local_pipeline = None
-
-if USE_LOCAL_MODEL:
-    import torch
-    from transformers import pipeline as _hf_pipeline
+_hf_token = os.getenv("HF_TOKEN")
+if not _hf_token:
+    raise ValueError("HF_TOKEN not found. Set it in your .env file.")
 
-    _local_pipeline = _hf_pipeline(
-        "text-generation",
-        model=LOCAL_MODEL_ID,
-        torch_dtype=torch.bfloat16,
-        device_map="auto",
-    )
-    LLM_CLIENT = None
-else:
-    _hf_token = os.getenv("HF_TOKEN")
-    if not _hf_token:
-        raise ValueError("HF_TOKEN not found. Set it in your .env file.")
-    LLM_CLIENT = InferenceClient(token=_hf_token)
+LLM_CLIENT = InferenceClient(token=_hf_token)
 
 
 def call_llm(prompt: str, system_prompt: str, seed: int, max_tokens: int = 300) -> str:
-    """
-    Call the LLM with the given prompt. Use this function in your agent.
-    
-    Args:
-        prompt: The user prompt (current game state, history, etc.)
-        system_prompt: The system prompt (instructions for the agent)
-        seed: Random seed for reproducibility
-        max_tokens: Maximum tokens in response (default: 300)
-        
-    Returns:
-        The LLM's response text
-        
-    Example:
-        response = call_llm(
-            prompt="You are in a forest. What do you do?",
-            system_prompt=SYSTEM_PROMPT,
-            seed=42,
-        )
-    """
+    """Call the LLM with the given prompt."""
     messages = [
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": prompt},
     ]
-
-    if USE_LOCAL_MODEL and _local_pipeline is not None:
-        outputs = _local_pipeline(
-            messages,
-            max_new_tokens=max_tokens,
-            temperature=0.0001,  # Near-deterministic (0.0 unsupported by some backends)
-            do_sample=True,
-        )
-        return outputs[0]["generated_text"][-1]["content"]
-
+    
     response = LLM_CLIENT.chat.completions.create(
         model=LLM_MODEL,
         messages=messages,
-        temperature=0.0,  # Deterministic for reproducibility
+        temperature=0.0,
         max_tokens=max_tokens,
         seed=seed,
     )
-
+    
     return response.choices[0].message.content
 
 
@@ -125,179 +60,370 @@ class RunResult:
 
 
 # =============================================================================
-# System Prompt - Customize this for your agent
+# System Prompt
 # =============================================================================
 
-SYSTEM_PROMPT = """You are playing a classic text adventure game.
+SYSTEM_PROMPT = """You are an expert text adventure game player. Your goal is to explore, collect treasures, and maximize your score.
 
-GOAL: Explore the world, solve puzzles, and maximize your score.
-
-AVAILABLE TOOLS (use via MCP):
-- play_action: Execute a game command (north, take lamp, open mailbox, etc.)
-- memory: Get current game state and history (if implemented)
-- inventory: Check what you're carrying (if implemented)
+AVAILABLE TOOLS (use these via MCP):
+1. play_action - Execute game commands (north, take lamp, open mailbox, etc.)
+2. memory - Get current game state, score, and recent history
+3. get_map - See explored locations and connections
+4. inventory - Check what you're carrying
 
 VALID GAME COMMANDS for play_action:
 - Movement: north, south, east, west, up, down, enter, exit
 - Objects: take <item>, drop <item>, open <thing>, close <thing>, examine <thing>
-- Other: look, inventory, read <thing>, turn on lamp
+- Light: turn on lamp, turn off lamp
+- Combat: attack <enemy> with <weapon>
+- Other: inventory, look, read <thing>, wait
+
+FORBIDDEN (will NOT work): check, inspect, search, grab, use, help
 
 RESPOND IN THIS EXACT FORMAT (no markdown):
-THOUGHT: <your reasoning about what to do next>
+THOUGHT: <brief reasoning about what to do next>
+MEMORY: <brief information you want to keep in memory, for example room you need to go back or object you need to find>
 TOOL: <tool_name>
-ARGS: <JSON arguments, e.g., {"action": "look"}>
+ARGS: <JSON arguments>
 
-Example:
-THOUGHT: I should look around to see where I am.
+Examples:
+THOUGHT: I need to see what's around me.
+MEMORY: I need to find a lamp
 TOOL: play_action
 ARGS: {"action": "look"}
-"""
+
+THOUGHT: Let me check my current state and score.
+MEMORY: I need to go back to the dark room
+TOOL: memory
+ARGS: {}
+
+THOUGHT: The mailbox might contain something useful.
+MEMORY: I need to go back to the dark room
+TOOL: play_action
+ARGS: {"action": "open mailbox"}
+
+STRATEGY:
+1. Start by looking around and checking memory
+2. Explore systematically - try all directions
+3. Pick up useful items (lamp, sword, etc.)
+4. Open containers (mailbox, window, etc.)
+5. Use get_map to avoid getting lost
+6. Turn on lamp before dark areas!
+
+DO NOT repeat the same action multiple times in a row."""
 
 
 # =============================================================================
-# Student Agent - IMPLEMENT THIS CLASS
+# Student Agent Implementation
 # =============================================================================
 
 class StudentAgent:
     """
-    Your ReAct agent implementation.
+    MCP ReAct Agent - A complete working example.
     
-    TODO:
-    1. Implement the run() method with the ReAct loop
-    2. Parse LLM responses to extract tool calls
-    3. Track state and avoid loops
-    
-    Use the provided call_llm() function to interact with the LLM.
+    This agent demonstrates:
+    - ReAct loop (Thought -> Tool -> Observation)
+    - Loop detection
+    - Action validation
+    - Score tracking via memory tool
     """
     
     def __init__(self):
-        """Initialize your agent here."""
-        # TODO: Initialize any state tracking you need
-        # self.history = []
-        # self.visited_locations = set()
-        pass
+        """Initialize the agent state."""
+        self.history: list[dict] = []
+        self.recent_actions: list[str] = []
+        self.score: int = 0
     
     async def run(
         self,
-        client,  # FastMCP Client connected to your MCP server
+        client,
         game: str,
         max_steps: int,
         seed: int,
         verbose: bool = False,
     ) -> RunResult:
-        """
-        Run the agent for a game session.
-        
-        Args:
-            client: FastMCP Client connected to your MCP server
-            game: Name of the game being played (e.g., "zork1")
-            max_steps: Maximum number of steps to take
-            seed: Random seed for reproducibility (use for LLM calls)
-            verbose: Whether to print detailed output
-            
-        Returns:
-            RunResult with final score and statistics
-        """
-        # TODO: Implement your ReAct loop here
-        #
-        # Basic structure:
-        # 1. Get initial observation (call play_action with "look")
-        # 2. Loop for max_steps:
-        #    a. Build prompt with current observation and history
-        #    b. Call LLM to get thought and action
-        #    c. Parse the response to extract tool and args
-        #    d. Call the tool via client.call_tool(tool_name, args)
-        #    e. Update history and state
-        #    f. Check for game over
-        # 3. Return RunResult with final statistics
-        
-        # Example of calling a tool:
-        # result = await client.call_tool("play_action", {"action": "look"})
-        # observation = result[0].text if result else "No response"
-        
-        # Example of calling the LLM:
-        # response = call_llm(
-        #     prompt="Current observation: " + observation,
-        #     system_prompt=SYSTEM_PROMPT,
-        #     seed=seed,
-        # )
-        
-        # Placeholder implementation - replace with your code
+        """Run the agent for a game session."""
         locations_visited = set()
         history = []
-        final_score = 0
         moves = 0
         
-        # TODO: Your implementation here
-        # ...
+        # Get list of available tools
+        tools = await client.list_tools()
+        tool_names = [t.name for t in tools]
+        
+        # Get initial observation
+        result = await client.call_tool("play_action", {"action": "look"})
+        observation = self._extract_result(result)
+        
+        # Track initial location
+        location = observation.split("\n")[0] if observation else "Unknown"
+        locations_visited.add(location)
+        memory=""
+        if verbose:
+            print(f"\n{observation}")
+        #last_get_map=False
+        # Main ReAct loop
+        for step in range(1, max_steps + 1):
+            # Build prompt with context
+            current_loc=await client.call_tool("get_current_map", {})
+            last_10_loc=await client.call_tool("get_last_10_rooms", {})
+            prompt = self._build_prompt(current_loc.content[0].text,last_10_loc.content[0].text,observation,memory)
+
+            print("==========")
+            print(current_loc.content[0].text)
+            print('PROMPT',prompt)
+            # Call LLM for reasoning (use step-based seed for variety)
+            response = call_llm(prompt, SYSTEM_PROMPT, seed + step)
+            
+
+
+            # Parse the response
+            memory, thought, tool_name, tool_args = self._parse_response(response, tool_names)
+            
+            if verbose:
+                print(f"\n--- Step {step} ---")
+                print(f"[THOUGHT] {thought}")
+                print(f"[LONG TERM MEMORY] {memory}")
+                print(f"[TOOL] {tool_name}({tool_args})")
+            
+            # Validate and fix common issues
+            tool_name, tool_args = self._validate_tool_call(tool_name, tool_args, tool_names)
+            """
+            if "you can't go that way" in observation.lower() and not last_get_map:
+                    if verbose:
+                        print(f"[WARNING] Wrong way - forcing 'get_map'")
+                    tool_args = {}
+                    tool_name="get_map"
+                    last_get_map=True
+            else : 
+                last_get_map=False
+            """
+            # Loop detection
+            if tool_name == "play_action":
+                action = tool_args.get("action", "look")
+                self.recent_actions.append(action)
+                if len(self.recent_actions) > 5:
+                    self.recent_actions = self.recent_actions[-5:]
+                
+                # Detect loops - if same action 3 times, force "look"
+                if len(self.recent_actions) >= 3 and len(set(self.recent_actions[-3:])) == 1:
+                    if verbose:
+                        print(f"[WARNING] Loop detected - forcing 'look'")
+                    tool_args = {"action": "look"}
+                    self.recent_actions.append("look")
+                
+                moves += 1
+            
+            # Execute the tool
+            try:
+                result = await client.call_tool(tool_name, tool_args)
+                observation = self._extract_result(result)
+                
+                if verbose:
+                    print(f"[RESULT] {observation}...")
+            except Exception as e:
+                observation = f"Error: {e}"
+                if verbose:
+                    print(f"[ERROR] {e}")
+            
+            # Track location
+            location = observation.split("\n")[0] if observation else "Unknown"
+            locations_visited.add(location)
+            
+            # Update history
+            self.history.append({
+                "step": step,
+                "thought": thought,
+                "tool": tool_name,
+                "args": tool_args,
+                "result": observation[:200]
+            })
+            if len(self.history) > 10:
+                self.history = self.history[-10:]
+            
+            # Track score from observation
+            self._update_score(observation)
+            
+            # Record in result history
+            history.append((thought, f"{tool_name}({tool_args})", observation[:100]))
+            
+            # Check for game over
+            if self._is_game_over(observation):
+                if verbose:
+                    print("\n*** GAME OVER ***")
+                break
         
         return RunResult(
-            final_score=final_score,
-            max_score=350,  # Zork1 max score, adjust if needed
+            final_score=self.score,
+            max_score=350,
             moves=moves,
             locations_visited=locations_visited,
-            game_completed=False,
+            game_completed=self._is_game_over(observation),
             history=history,
         )
+    def _build_prompt(self,current_loc, last_10_loc, observation, memory) -> str:
+        """Build the prompt for the LLM with context."""
+        parts = []
+        
+        parts.append(f"Current Score: {self.score}")
+        
+        parts.append(f"\nYour long-term memory: {memory}")
+        # Recent history
+        if self.history:
+            parts.append("\nRecent actions:")
+            for entry in self.history[-3:]:
+                action = entry.get("args", {}).get("action", entry["tool"])
+                result_short = entry["result"][:80] + "..." if len(entry["result"]) > 80 else entry["result"]
+                parts.append(f"  > {action} -> {result_short}")
+            
+            # Warn about repeated actions
+            if self.recent_actions and len(set(self.recent_actions[-3:])) == 1:
+                parts.append(f"\n[WARNING: You've been doing '{self.recent_actions[-1]}' repeatedly. TRY SOMETHING DIFFERENT!]")
+
+        parts.append(last_10_loc)
+        parts.append(f"\nCurrent location and past actions you already explored in this location, you can and you should test other actions:\n{current_loc}")
+        parts.append(f"\nCurrent situation:\n{observation}")
+        parts.append("\nWhat do you do next?")
+        
+        return "\n".join(parts)
     
-    def _build_prompt(self, observation: str, history: list) -> str:
-        """
-        Build the prompt for the LLM.
+    def _parse_response(self, response: str, valid_tools: list[str]) -> tuple[str, str, dict]:
+        """Parse the LLM response to extract thought, tool, and arguments."""
+        thought = "No reasoning provided"
+        memory="No memory provided"
+        tool_name = "play_action"
+        tool_args = {"action": "look"}
+        
+        lines = response.strip().split("\n")
+        
+        for line in lines:
+            line_clean = line.strip()
+            line_upper = line_clean.upper()
+            
+            if line_upper.startswith("THOUGHT:"):
+                thought = line_clean.split(":", 1)[1].strip()
+            
+            elif line_upper.startswith("MEMORY:"):
+                memory = line_clean.split(":", 1)[1].strip()
+
+            elif line_upper.startswith("TOOL:"):
+                raw_tool = line_clean.split(":", 1)[1].strip().lower()
+                raw_tool = raw_tool.replace("**", "").replace("*", "").replace("`", "")
+                raw_tool = raw_tool.split()[0] if raw_tool else "play_action"
+                tool_name = raw_tool
+            
+            elif line_upper.startswith("ARGS:"):
+                args_part = line_clean.split(":", 1)[1].strip()
+                try:
+                    args_part = args_part.replace("'", '"')
+                    tool_args = json.loads(args_part)
+                except json.JSONDecodeError:
+                    match = re.search(r'"action"\s*:\s*"([^"]+)"', args_part)
+                    if match:
+                        tool_args = {"action": match.group(1)}
+                    else:
+                        tool_args = {"action": "look"}
         
-        TODO: Implement this to create effective prompts
-        """
-        # TODO: Combine system prompt, history, and current observation
-        pass
+        return memory,thought, tool_name, tool_args
     
-    def _parse_response(self, response: str) -> tuple[str, str, dict]:
-        """
-        Parse LLM response to extract thought, tool name, and arguments.
+    def _validate_tool_call(self, tool_name: str, tool_args: dict, valid_tools: list[str]) -> tuple[str, dict]:
+        """Validate and fix common tool call issues."""
+        # Fix tool name
+        if tool_name not in valid_tools:
+            if tool_name in ["action", "do", "command"]:
+                tool_name = "play_action"
+            elif tool_name in ["map", "location"]:
+                tool_name = "get_map"
+            elif tool_name in ["mem", "state", "status"]:
+                tool_name = "memory"
+            elif tool_name in ["inv", "items"]:
+                tool_name = "inventory"
+            else:
+                tool_name = "play_action"
         
-        TODO: Implement robust parsing
+        # Fix action verbs
+        if tool_name == "play_action":
+            action = tool_args.get("action", "look")
+            
+            invalid_verb_map = {
+                "check": "examine",
+                "inspect": "examine",
+                "search": "look",
+                "grab": "take",
+                "pick": "take",
+                "use": "examine",
+                "investigate": "examine",
+            }
+            
+            words = action.lower().split()
+            if words and words[0] in invalid_verb_map:
+                words[0] = invalid_verb_map[words[0]]
+                action = " ".join(words)
+            
+            action = action.lower().strip()
+            action = action.replace("**", "").replace("*", "").replace("`", "")
+            action = " ".join(action.split())
+            
+            tool_args["action"] = action
         
-        Returns:
-            Tuple of (thought, tool_name, args_dict)
-        """
-        # TODO: Parse the response format:
-        # THOUGHT: ...
-        # TOOL: ...
-        # ARGS: {...}
-        pass
+        return tool_name, tool_args
     
-    def _call_llm(self, prompt: str, system_prompt: str, seed: int) -> str:
-        """
-        Call the LLM with the given prompt.
+    def _extract_result(self, result) -> str:
+        """Extract text from MCP tool result."""
+        if hasattr(result, 'content') and result.content:
+            return result.content[0].text
+        if isinstance(result, list) and result:
+            return result[0].text if hasattr(result[0], 'text') else str(result[0])
+        return str(result)
+    
+    def _update_score(self, text: str) -> None:
+        """Update score from game text."""
+        patterns = [
+            r'Score:\s*(\d+)',
+            r'score[:\s]+(\d+)',
+            r'\[Score:\s*(\d+)',
+        ]
         
-        This is a convenience wrapper - you can also use call_llm() directly.
-        """
-        return call_llm(prompt, system_prompt, seed)
+        for pattern in patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                self.score = max(self.score, int(match.group(1)))
+    
+    def _is_game_over(self, text: str) -> bool:
+        """Check if the game is over."""
+        game_over_phrases = [
+            "game over",
+            "you have died",
+            "you are dead",
+            "*** you have died ***",
+        ]
+        text_lower = text.lower()
+        return any(phrase in text_lower for phrase in game_over_phrases)
 
 
 # =============================================================================
-# For local testing
+# Local Testing
 # =============================================================================
 
 async def test_agent():
     """Test the agent locally."""
     from fastmcp import Client
     
-    # Path to your MCP server
-    server_path = "mcp_server.py"
-    
     agent = StudentAgent()
     
-    async with Client(server_path) as client:
+    async with Client("mcp_server.py") as client:
         result = await agent.run(
             client=client,
             game="zork1",
-            max_steps=10,
+            max_steps=100,
             seed=42,
             verbose=True,
         )
         
-        print(f"\nFinal Score: {result.final_score}")
+        print(f"\n{'=' * 50}")
+        print(f"Final Score: {result.final_score}")
         print(f"Moves: {result.moves}")
-        print(f"Locations: {result.locations_visited}")
+        print(f"Locations: {len(result.locations_visited)}")
 
 
 if __name__ == "__main__":

mcp_server.py

@@ -1,27 +1,8 @@
 """
-Student MCP Server for Text Adventure Games
+Example: MCP Server for Text Adventures
 
-This is your MCP server submission. Implement the tools that your agent
-will use to play text adventure games.
-
-Required tool:
-    play_action(action: str) -> str
-        Execute a game command and return the result.
-
-Recommended tools:
-    memory() -> str
-        Return current game state, score, and recent history.
-    
-    inventory() -> str  
-        Return the player's current inventory.
-    
-    get_map() -> str
-        Return a map of explored locations.
-
-Test your server with:
-    fastmcp dev submission_template/mcp_server.py
-
-Then open the MCP Inspector in your browser to test the tools interactively.
+A complete MCP server that exposes text adventure games via tools.
+This demonstrates a full-featured server with memory, mapping, and inventory.
 """
 
 import sys
@@ -31,179 +12,232 @@ import os
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from fastmcp import FastMCP
-from games.zork_env import TextAdventureEnv
+from games.zork_env import TextAdventureEnv, list_available_games
 
 
-# =============================================================================
-# Create the MCP Server
-# =============================================================================
+# Get game from environment variable (default: zork1)
+INITIAL_GAME = os.environ.get("GAME", "zork1")
 
-mcp = FastMCP("Student Text Adventure Server")
+# Create the MCP server
+mcp = FastMCP("Text Adventure Server")
 
 
-# =============================================================================
-# Game State Management
-# =============================================================================
-
-class GameManager:
-    """
-    Manages the text adventure game state.
-    
-    TODO: Extend this class to track:
-    - Action history (for memory tool)
-    - Explored locations (for mapping)
-    - Current score and moves
-    """
-    
-    def __init__(self):
-        self.env: TextAdventureEnv = None
-        self.state = None
-        self.game_name: str = ""
-        # TODO: Add more state tracking
-        # self.history: list[tuple[str, str]] = []
-        # self.explored_locations: dict[str, set[str]] = {}
-        # self.current_location: str = ""
+class GameState:
+    """Manages the text adventure game state and exploration data."""
     
-    def initialize(self, game: str = "zork1"):
-        """Initialize or reset the game."""
+    def __init__(self, game: str = "zork1"):
         self.game_name = game
         self.env = TextAdventureEnv(game)
         self.state = self.env.reset()
-        # TODO: Reset your state tracking here
-        return self.state.observation
-    
-    def step(self, action: str) -> str:
-        """Execute an action and return the result."""
-        if self.env is None:
-            self.initialize()
+        self.history: list[tuple[str, str]] = []
+        self.explored_locations: dict[str, set[str]] = {"West of House": set()}
+        self.current_location: str = "West of House"
+        self.last_loc="West of House"
+        self.last_dir=""
+        self.last_10_loc=[]
+        self.last_10_dir=[]
+    def _extract_location(self, observation: str) -> str:
+        """Extract location name from observation (usually first line)."""
         
+        lines = observation.strip().split('\n')
+        return lines[0] if lines else "Unknown"
+    
+    def take_action(self, action: str) -> str:
+        """Execute a game action and return the result."""
         self.state = self.env.step(action)
+        result = self.state.observation
         
-        # TODO: Update your state tracking here
-        # self.history.append((action, self.state.observation))
-        # Update location tracking, etc.
+        # Track history
+        self.history.append((action, result))
+        if len(self.history) > 50:
+            self.history = self.history[-50:]
         
-        return self.state.observation
+        # Update map
+        new_location = self._extract_location(result)
+        directions = ["northwest", "southwest", "northeast", "southeast","north", "south", "east", "west","up", "down", "enter", "exit", "go"]
+        if any(d in action for d in directions) or action in ["s", "w", "e", "n"]:
+            self.explored_locations[self.current_location].add(f"{action} -> {new_location}")
+            if len(new_location.split())<=4 or "dark" in new_location and new_location!=self.current_location:
+                if new_location not in self.explored_locations:
+                    self.explored_locations[new_location] = set()
+                self.last_loc=self.current_location
+                self.last_10_loc.append(self.current_location)
+                self.last_10_dir.append(action)
+                if len(self.last_10_loc)>10 :
+                    self.last_10_loc=self.last_10_loc[1:]
+                    self.last_10_dir=self.last_10_dir[1:]
+                self.last_dir=action
+                self.current_location = new_location
+
+
+        
+        return result
     
-    def get_score(self) -> int:
-        """Get current score."""
-        return self.state.score if self.state else 0
+    def get_memory(self) -> str:
+        """Get a summary of current game state."""
+        recent = self.history[-5:] if self.history else []
+        recent_str = "\n".join([f"  > {a} -> {r[:60]}..." for a, r in recent]) if recent else "  (none yet)"
+        
+        return f"""Current State:
+- Location: {self.current_location}
+- Score: {self.state.score} points
+- Moves: {self.state.moves}
+- Game: {self.game_name}
+
+Recent Actions:
+{recent_str}
+
+Current Observation:
+{self.state.observation}"""
     
-    def get_moves(self) -> int:
-        """Get number of moves taken."""
-        return self.state.moves if self.state else 0
+    def get_map(self) -> str:
+        """Get a map of explored locations."""
+        if not self.explored_locations:
+            return "Map: No locations explored yet. Try moving around!"
+        
+        lines = ["Explored Locations and explored Exits:"]
+        for loc, exits in sorted(self.explored_locations.items()):
+            lines.append(f"\n* {loc}")
+            for exit_info in sorted(exits):
+                lines.append(f"    -> {exit_info}")
+        
+        lines.append(f"\n[Current] {self.current_location}")
+        return "\n".join(lines)
+    def get_last_10_rooms(self) :
+        res="\nLast rooms explored : "
+        for loc, dir in zip(self.last_10_loc,self.last_10_dir):
+            res+=f" {loc} -> {dir} -> "
+        return res
+
+    def get_current_map(self) -> str:
+        if not self.current_location:
+            return "Map: No locations explored yet. Try moving around!"
+        
+        exits = self.explored_locations.get(self.current_location, set())
 
+        lines=[f"Current location : {self.current_location}"]
+ 
+        lines.append("rooms before :")
 
-# Global game manager
-_game = GameManager()
+        lines.append(self.last_loc+ " -> " +self.last_dir )
+        
+        if exits:
+            lines.append("explored exits:")
+            for e in sorted(exits):
+                lines.append(f"  -> {e}")
+        else:
+            lines.append("No recorded exits yet.")
+        return "\n".join(lines)
+    
+    def get_inventory(self) -> str:
+        """Get current inventory."""
+        items = self.state.inventory if hasattr(self.state, 'inventory') and self.state.inventory else []
+        
+        if not items:
+            return "Inventory: You are empty-handed."
+        
+        item_names = []
+        for item in items:
+            item_str = str(item)
+            item_lower = item_str.lower()
+            if "parent" in item_lower:
+                idx = item_lower.index("parent")
+                name = item_str[:idx].strip()
+                if ":" in name:
+                    name = name.split(":", 1)[1].strip()
+                item_names.append(name)
+            elif ":" in item_str:
+                name = item_str.split(":")[1].strip()
+                item_names.append(name)
+            else:
+                item_names.append(item_str)
+        
+        return f"Inventory: {', '.join(item_names)}"
+
+
+# Global game state
+_game_state: GameState | None = None
 
 
-def get_game() -> GameManager:
-    """Get or initialize the game manager."""
-    global _game
-    if _game.env is None:
-        # Get game from environment variable (set by evaluator)
-        game = os.environ.get("GAME", "zork1")
-        _game.initialize(game)
-    return _game
+def get_game() -> GameState:
+    """Get or initialize the game state."""
+    global _game_state
+    if _game_state is None:
+        _game_state = GameState(INITIAL_GAME)
+    return _game_state
 
 
 # =============================================================================
-# MCP Tools - IMPLEMENT THESE
+# MCP Tools
 # =============================================================================
 
 @mcp.tool()
 def play_action(action: str) -> str:
     """
-    Execute a game command and return the result.
-    
-    This is the main tool for interacting with the game.
+    Execute a game action in the text adventure.
     
     Args:
-        action: The command to execute (e.g., "north", "take lamp", "open mailbox")
-        
+        action: The command to execute (e.g., 'north', 'take lamp', 'open mailbox')
+    
     Returns:
-        The game's response to the action
-        
-    Valid commands include:
-        - Movement: north, south, east, west, up, down, enter, exit
-        - Objects: take <item>, drop <item>, open <thing>, examine <thing>
-        - Other: look, inventory, read <thing>, turn on lamp
+        The game's response to your action
     """
     game = get_game()
+    result = game.take_action(action)
+    
+    # Add score info
+    score_info = f"\n\n[Score: {game.state.score} | Moves: {game.state.moves}]"
     
-    # TODO: You might want to add action validation here
-    # TODO: You might want to include score changes in the response
+    if game.state.reward > 0:
+        score_info = f"\n\n+{game.state.reward} points! (Total: {game.state.score})"
     
-    result = game.step(action)
+    done_info = ""
+    if game.state.done:
+        done_info = "\n\nGAME OVER"
+    
+    return result + score_info + done_info
+
+
+@mcp.tool()
+def memory() -> str:
+    """
+    Get a summary of the current game state.
     
-    # Optional: Append score info
-    # result += f"\n[Score: {game.get_score()} | Moves: {game.get_moves()}]"
+    Returns location, score, moves, recent actions, and current observation.
+    """
+    return get_game().get_memory()
+
+
+@mcp.tool()
+def get_map() -> str:
+    """
+    Get a map showing explored locations and connections.
     
-    return result
-
-
-# TODO: Implement additional tools to help your agent
-
-# @mcp.tool()
-# def memory() -> str:
-#     """
-#     Get the current game state summary.
-#     
-#     Returns:
-#         A summary including current location, score, moves, and recent history
-#     """
-#     game = get_game()
-#     # TODO: Return useful state information
-#     pass
-
-
-# @mcp.tool()
-# def inventory() -> str:
-#     """
-#     Check what the player is carrying.
-#     
-#     Returns:
-#         List of items in the player's inventory
-#     """
-#     game = get_game()
-#     result = game.step("inventory")
-#     return result
-
-
-# @mcp.tool()
-# def get_map() -> str:
-#     """
-#     Get a map of explored locations.
-#     
-#     Returns:
-#         A text representation of explored locations and connections
-#     """
-#     game = get_game()
-#     # TODO: Return map of explored locations
-#     pass
-
-
-# @mcp.tool()
-# def get_valid_actions() -> str:
-#     """
-#     Get a list of likely valid actions from the current location.
-#     
-#     Returns:
-#         List of actions that might work here
-#     """
-#     # This is a hint: Jericho provides get_valid_actions()
-#     game = get_game()
-#     if game.env and game.env.env:
-#         valid = game.env.env.get_valid_actions()
-#         return "Valid actions: " + ", ".join(valid[:20])
-#     return "Could not determine valid actions"
+    Useful for navigation and avoiding getting lost.
+    """
+    return get_game().get_map()
+
+@mcp.tool()
+def get_current_map() -> str:
+    """Get current location."""
+    return get_game().get_current_map()
+
+@mcp.tool()
+def get_last_10_rooms() -> str:
+    """Get last 10 locations and directions."""
+    return get_game().get_last_10_rooms()
+
+@mcp.tool()
+def inventory() -> str:
+    """
+    Check what items you are currently carrying.
+    """
+    return get_game().get_inventory()
 
 
 # =============================================================================
-# Run the server
+# Main
 # =============================================================================
 
 if __name__ == "__main__":
-    # This runs the server with stdio transport (for MCP clients)
     mcp.run()