SQL Agent with Smolagents

how would you adapt this: https://www.reddit.com/r/ChatGPTCoding/comments/1jd9lfa/learn_mcp_by_building_an_sql_ai_agent/ to work with smolagents and locally run Ollama models

To adapt the approach from the Reddit post "Learn MCP by building an SQL AI agent" to work with Hugging Face's `smolagents` framework and locally run models using Ollama, follow these steps: 1. **Set Up Ollama for Local Model Hosting**: - **Install Ollama**: - Ollama allows you to run large language models (LLMs) locally. citeturn0search3 - Download and install Ollama from their official website. - **Download a Suitable LLM**: - Choose a model compatible with your SQL agent's requirements. For instance, Llama 2 is a collection of foundation language models ranging from 7B to 70B parameters. citeturn0search11 - Use the command `ollama pull llama2` to download the model. 2. **Install and Configure `smolagents`**: - **Install the Library**: - Install `smolagents` using pip: ```bash pip install smolagents ``` - **Integrate Ollama with `smolagents`**: - `smolagents` supports various LLM providers, including Ollama. citeturn0search2 - Configure the agent to use the Ollama-hosted model: ```python from smolagents import OllamaModel, CodeAgent model = OllamaModel(model="llama2") agent = CodeAgent(model=model, tools=[/* your tools here */]) ``` 3. **Develop SQL Execution Tools**: - **Create Tools for SQL Operations**: - Define tools that the agent can use to interact with your SQL database. - Each tool should handle specific SQL operations, such as querying or updating data. - **Example Tool Definition**: ```python from smolagents import Tool class SQLQueryTool(Tool): def __init__(self, connection): self.connection = connection def run(self, query): cursor = self.connection.cursor() cursor.execute(query) return cursor.fetchall() ``` 4. **Assemble the Agent**: - **Initialize the Agent with Tools**: - Combine the LLM and tools to create the agent: ```python agent = CodeAgent(model=model, tools=[SQLQueryTool(connection)]) ``` - **Define Agent Behavior**: - Specify how the agent should process inputs and utilize tools to perform tasks. 5. **Test and Iterate**: - **Validate Functionality**: - Run test cases to ensure the agent correctly interprets inputs and interacts with the SQL database as intended. - **Refine Based on Feedback**: - Continuously improve the agent's performance based on testing outcomes. By following these steps, you can adapt the original SQL AI agent concept to utilize `smolagents` and locally hosted models via Ollama, enabling efficient and private AI-driven SQL operations.

no I want to use MCP

To adapt the SQL AI agent project from the Reddit post to work with the Model Context Protocol (MCP) and locally run models using Ollama, you can follow these steps: 1. **Set Up Ollama for Local Model Hosting**: - **Install Ollama**: - Ollama enables you to run large language models (LLMs) locally. - Download and install Ollama from their official website. - **Download a Suitable LLM**: - Choose a model compatible with your SQL agent's requirements. For instance, Llama 2 is a collection of foundation language models ranging from 7B to 70B parameters. - Use the command `ollama pull llama2` to download the model. 2. **Develop the MCP Server**: - **Implement SQL Execution Tools**: - Define tools that the MCP server can expose for SQL operations. - Each tool should handle specific SQL tasks, such as querying or updating data. - **Example Tool Definition**: ```python import sqlite3 from loguru import logger from mcp.server.fastmcp import FastMCP mcp = FastMCP("SQL Agent Server") @mcp.tool() def query_data(sql: str) -> str: """Execute SQL queries safely.""" logger.info(f"Executing SQL query: {sql}") conn = sqlite3.connect("./database.db") try: result = conn.execute(sql).fetchall() conn.commit() return "\n".join(str(row) for row in result) except Exception as e: return f"Error: {str(e)}" finally: conn.close() if __name__ == "__main__": print("Starting server...") mcp.run(transport="stdio") ``` - This script sets up an MCP server with a tool to execute SQL queries on a SQLite database. 3. **Develop the MCP Client**: - **Integrate the Ollama-Hosted Model**: - Configure the MCP client to use the locally hosted LLM via Ollama. - **Example Client Implementation**: ```python import asyncio from dataclasses import dataclass, field from typing import Union, cast from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client server_params = StdioServerParameters(command="python", args=["./mcp_server.py"], env=None) class Chat: messages: list = field(default_factory=list) system_prompt: str = """You are a master SQLite assistant. Your job is to use the tools at your disposal to execute SQL queries and provide the results to the user.""" async def process_query(self, session: ClientSession, query: str) -> None: response = await session.list_tools() available_tools = [ {"name": tool.name, "description": tool.description or "", "input_schema": tool.inputSchema} for tool in response.tools ] # Further implementation to process the query using the available tools ``` - This client sets up a session with the MCP server and prepares to utilize the tools exposed by the server. 4. **Test and Iterate**: - **Validate Functionality**: - Run test cases to ensure the agent correctly interprets inputs and interacts with the SQL database as intended. - **Refine Based on Feedback**: - Continuously improve the agent's performance based on testing outcomes. By following these steps, you can adapt the original SQL AI agent concept to utilize the Model Context Protocol (MCP) and locally hosted models via Ollama, enabling efficient and private AI-driven SQL operations. For a visual walkthrough of building an SQL AI agent using MCP, you might find this tutorial helpful: videoLearn MCP by building an SQL AI agentturn0search1

let's do something other than SQL and instead create something which uses browser-use instead for this project

To adapt the Model Context Protocol (MCP) for browser automation using locally hosted models with Ollama, you can utilize existing MCP servers designed for browser control. Here's a step-by-step guide to achieve this: 1. **Set Up Ollama for Local Model Hosting**: - **Install Ollama**: - Ollama enables you to run large language models (LLMs) locally. - Download and install Ollama from their official website: [Ollama](https://ollama.com/) - **Download a Suitable LLM**: - Choose a model compatible with your browser automation requirements. For instance, Llama 3.3 is available for local use. - Use the command `ollama pull llama3.3` to download the model. 2. **Integrate Browser Automation with MCP**: - **Utilize Existing MCP Servers**: - Several MCP servers offer browser automation capabilities: - **MCP Playwright Server**: Leverages Playwright to control browser actions. - Repository: [executeautomation/mcp-playwright](https://github.com/executeautomation/mcp-playwright) - **Browserbase MCP Server**: Utilizes Browserbase and Puppeteer for cloud-based browser automation. - Repository: [browserbase/mcp-server-browserbase](https://github.com/browserbase/mcp-server-browserbase) - **MCP Browser Automation Server**: Provides automation through a REST API, supporting tasks like navigation, screenshots, and console log monitoring. - More information: [MCP Browser Automation Server](https://mcp.so/server/mcp-browser-automation) - **Installation and Configuration**: - Clone the chosen repository and follow the provided setup instructions to install dependencies and configure the server. - Ensure that the MCP server is running and accessible for client connections. 3. **Develop the MCP Client**: - **Integrate the Ollama-Hosted Model**: - Configure the MCP client to use the locally hosted LLM via Ollama. - **Example Client Implementation**: ```python import asyncio from mcp import ClientSession, StdioServerParameters server_params = StdioServerParameters(command="python", args=["./mcp_server.py"], env=None) async def main(): async with ClientSession(server_params) as session: # List available tools tools = await session.list_tools() print("Available tools:", tools) # Example: Navigate to a URL navigate_tool = next(tool for tool in tools if tool.name == "navigate") await session.run_tool(navigate_tool, {"url": "https://example.com"}) if __name__ == "__main__": asyncio.run(main()) ``` - This client sets up a session with the MCP server and utilizes the tools exposed by the server for browser automation tasks. 4. **Test and Iterate**: - **Validate Functionality**: - Run test cases to ensure the agent correctly interprets inputs and interacts with the web browser as intended. - **Refine Based on Feedback**: - Continuously improve the agent's performance based on testing outcomes. By following these steps, you can adapt the MCP for browser automation using locally hosted models via Ollama, enabling efficient and private AI-driven web interactions. For a visual walkthrough of integrating Ollama with browser automation, you might find this tutorial helpful: videoBrowser Use with Ollama: Local AI Agents for Website Interactionturn0search1

Below is one way to repurpose the project from using SQL queries to instead performing browser interactions—all while leveraging MCP and locally run Ollama models. Below is an overview of the key steps and example code snippets to guide you through the process: --- ### 1. Set Up Your Local Environment - **Ollama & Local LLMs:** First, ensure that you have Ollama installed and a model downloaded (for example, Llama 2). This will power your language model locally. - **MCP Framework:** Make sure you have the MCP framework installed so that you can build and run both the server and the client. --- ### 2. Build the MCP Server with a Browser Automation Tool Instead of a tool that executes SQL queries, you’ll create one that performs browser actions. In this example, we use Selenium to open a URL and return the page title. (You can extend this to do more advanced tasks like clicking buttons, filling forms, or extracting specific data.) > **Note:** Installing Selenium and its dependencies (like a web driver) is required. For example, you might use: > > ```bash > pip install selenium webdriver-manager > ``` #### **Example MCP Server Code:** ```python import time from selenium import webdriver from selenium.webdriver.chrome.service import Service as ChromeService from webdriver_manager.chrome import ChromeDriverManager from mcp.server.fastmcp import FastMCP # Initialize the MCP server with a descriptive name. mcp = FastMCP("Browser Agent Server") @mcp.tool() def navigate(url: str) -> str: """ Navigates to a given URL using a headless Chrome browser and returns the page title. """ # Set up headless Chrome options. options = webdriver.ChromeOptions() options.add_argument("--headless") # Initialize the Chrome driver. driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()), options=options) try: driver.get(url) time.sleep(2) # Give the page time to load. title = driver.title return f"Page title: {title}" except Exception as e: return f"Error: {str(e)}" finally: driver.quit() if __name__ == "__main__": print("Starting MCP Browser Agent Server...") mcp.run(transport="stdio") ``` This script creates an MCP tool named `navigate` that: - Launches a headless browser, - Opens the provided URL, - Waits briefly for the page to load, and - Returns the page title as output. --- ### 3. Create an MCP Client That Leverages the Browser Tool Your client code will connect to the MCP server, list available tools, and then use the browser automation tool. In addition, you can integrate your locally hosted Ollama model into the agent’s workflow to generate instructions or parse user input. #### **Example MCP Client Code:** ```python import asyncio from mcp.client.stdio import stdio_client from mcp import ClientSession, StdioServerParameters # Define the parameters for the MCP server; adjust the command/args as needed. server_params = StdioServerParameters( command="python", args=["./mcp_browser_server.py"] ) async def run_client(): # Connect to the MCP server. async with stdio_client(server_params) as session: # List the available tools (for debugging or dynamic agent behavior). tools = await session.list_tools() print("Available tools:", [tool.name for tool in tools.tools]) # Use the 'navigate' tool to visit a URL. response = await session.run_tool("navigate", {"url": "https://example.com"}) print("Response:", response) if __name__ == "__main__": asyncio.run(run_client()) ``` This client: - Connects to the MCP server, - Optionally lists the tools to see what’s available, - Invokes the `navigate` tool with a sample URL, and - Prints out the response. --- ### 4. Integrate the Ollama-Hosted Model with Your Agent To combine the MCP server with your locally run Ollama model: - **Set Up Your LLM:** Use your preferred integration method from the `smolagents` or similar frameworks to initialize an Ollama model instance. - **Define Your Agent’s System Prompt:** For example, update your agent’s prompt to: *"You are a browser automation assistant. Use the tools available to navigate webpages, extract information, and report back to the user."* - **Bridge MCP and LLM:** You can have the LLM parse natural language queries into calls to the `navigate` tool or other browser tools you might create. A simplified code snippet might look like this: ```python from smolagents import OllamaModel, CodeAgent # Initialize the Ollama model (adjust model name as needed). model = OllamaModel(model="llama2") agent = CodeAgent( model=model, tools=[ # Pass your MCP browser tool if you have a local interface for it. # Your tool wrappers could be added here. ], system_prompt="You are a browser automation assistant. Use available tools to interact with webpages." ) # You can now use `agent` to process natural language queries and dispatch them to your MCP server. ``` --- ### 5. Test and Iterate - **Validation:** Run the MCP server and client scripts to ensure the browser automation functions as expected. Test with various URLs and browser tasks. - **Enhancements:** Consider expanding your browser tool to support additional actions (e.g., form submissions, clicking elements) as your project grows. - **Error Handling and Security:** Always validate user input and handle exceptions to avoid unwanted behavior during browser automation. --- By following these steps, you adapt the original MCP SQL agent concept into a browser automation project—using MCP to expose browser tools and integrating a locally hosted Ollama model for natural language processing and decision-making. This setup lets you process natural language queries, have your agent interpret them, and then perform browser-based actions accordingly.

now write a series of prompts I can give cline in order to build this

Here’s a structured set of prompts you can give to **Cline** to guide the development of this MCP-powered browser automation agent. The prompts are designed to help you build the project step by step, integrating **MCP, Selenium, and Ollama** with `smolagents`. --- ## **1. Setting Up the MCP Server** > **Prompt:** *"Write a Python script that initializes an MCP server using FastMCP. The server should expose a tool called `navigate` that takes a URL as input, launches a headless Chrome browser using Selenium, and returns the page title. Ensure proper error handling and browser cleanup."* --- ## **2. Creating the MCP Client** > **Prompt:** *"Write a Python script that acts as an MCP client. It should connect to the MCP server, list available tools, and invoke the `navigate` tool with a test URL, printing the response."* --- ## **3. Enhancing the Browser Agent with More Actions** ### (Clicking Buttons, Filling Forms, Extracting Text) > **Prompt:** *"Modify the MCP server script to include additional browser automation tools: 1. `click_element` – Takes a CSS selector and clicks the corresponding element. 2. `fill_form` – Takes a CSS selector and input text, then fills the form field. 3. `extract_text` – Takes a CSS selector and returns the text content. Ensure the browser persists across requests and only closes when necessary."* --- ## **4. Integrating Ollama as a Natural Language Interface** > **Prompt:** *"Write a Python script that initializes an Ollama model using `smolagents.OllamaModel`. This model should receive natural language prompts and convert them into structured tool calls for MCP. Set up a `CodeAgent` with a system prompt instructing it to use available browser tools."* --- ## **5. Connecting the Ollama Model to the MCP Client** > **Prompt:** *"Modify the MCP client script to integrate with the Ollama model. The Ollama-generated output should be parsed to extract tool names and parameters, which are then passed to the MCP client for execution. Ensure it dynamically selects the correct tool based on user queries."* --- ## **6. Expanding the Agent’s Capabilities with Browser Persistence** > **Prompt:** *"Modify the MCP server so that it maintains a persistent browser session for multiple requests. Ensure that each tool execution reuses the existing browser session rather than opening and closing a new browser instance every time."* --- ## **7. Adding a Conversational Interface** > **Prompt:** *"Write a script that acts as a conversational interface, allowing users to chat with the browser agent. The agent should parse user input, decide which MCP tool to use, and execute browser actions accordingly. Responses should be natural and informative."* --- ## **8. Deploying and Running Everything Together** > **Prompt:** *"Write a Bash script or a `run.py` script that launches the MCP server, MCP client, and Ollama agent in the correct order. Ensure proper handling of process management and logging."* --- ## **9. Testing and Debugging the Full System** > **Prompt:** *"Write a series of test cases using `pytest` to verify that each MCP tool works correctly. Include tests for navigating to a webpage, clicking a button, filling a form, and extracting text."* --- ### **Next Steps** Once you’ve run these prompts through Cline, you'll have a working browser automation system using MCP, SmolAgents, and Ollama. Let me know if you need refinements or additional features! 🚀

Below is a series of prompts you can feed into your CLI (or an interactive agent) step by step to build the browser automation project using MCP and locally hosted Ollama models. You can use these prompts as a guided walkthrough: --- 1. **Set Up the Environment** **Prompt:** > "List the prerequisites and commands to install MCP, Selenium, webdriver-manager, and Ollama. Include commands like `pip install mcp selenium webdriver-manager` and instructions to download a model using Ollama (e.g., `ollama pull llama2`)." 2. **Create the MCP Server with a Browser Automation Tool** **Prompt:** > "Generate a complete Python script for an MCP server that defines a tool called `navigate`. This tool should use Selenium with headless Chrome to navigate to a URL, wait for the page to load, and return the page title. Make sure to handle exceptions and quit the driver gracefully." 3. **Review and Save the Server Code** **Prompt:** > "Display the code for the MCP browser server so I can review and save it as `mcp_browser_server.py`." 4. **Build the MCP Client to Interact with the Browser Tool** **Prompt:** > "Provide a complete Python script for an MCP client that connects to the `mcp_browser_server.py`, lists available tools, and then calls the `navigate` tool with a sample URL (for example, `https://example.com`). The client should print the returned response." 5. **Integrate the Locally Hosted Ollama Model** **Prompt:** > "Show me how to initialize an Ollama model (e.g., Llama 2) using a framework like `smolagents` and integrate it with the MCP client. Include a sample system prompt instructing the agent to act as a browser automation assistant." 6. **Set the Agent’s System Prompt** **Prompt:** > "Provide an example of a system prompt for the agent that directs it to use available browser tools to navigate web pages, extract information, and handle browser actions." 7. **Test the Entire Pipeline** **Prompt:** > "Explain the steps and commands needed to run the MCP server and client. Include instructions to run the server script (e.g., `python mcp_browser_server.py`) and then the client script (e.g., `python mcp_browser_client.py`), and how to verify that the browser automation (retrieving a page title) works correctly." 8. **Extend Functionality** **Prompt:** > "List some ideas and code suggestions on how I can extend this project. For example, add tools for clicking buttons, filling out forms, or extracting specific page elements. Provide sample code snippets where applicable." --- Using these prompts one after the other in your CLI or interactive agent should guide you through building, testing, and extending your browser automation project powered by MCP and locally hosted Ollama models. Enjoy building your project!

List the prerequisites and commands to install MCP, Selenium, webdriver-manager, and Ollama. Include commands like pip install mcp selenium webdriver-manager and instructions to download a model using Ollama (e.g., ollama pull llama2).

Here are the prerequisites and installation commands to set up your environment for building the MCP browser automation project with Selenium, MCP, and Ollama. --- ### **Prerequisites** Before running the setup commands, ensure you have the following installed: 1. **Python 3.8+** – Required to run MCP, Selenium, and Ollama integrations. - Check if Python is installed: ```bash python --version ``` - If not installed, download it from [python.org](https://www.python.org/downloads/). 2. **Pip (Python Package Manager)** – Comes with Python, but verify it: ```bash pip --version ``` If pip is missing, install it: ```bash python -m ensurepip --upgrade ``` 3. **Git (for MCP and version control, if needed)** - Check if Git is installed: ```bash git --version ``` - If not installed, download from [git-scm.com](https://git-scm.com/). 4. **Google Chrome (for Selenium WebDriver automation)** - Download from [chrome.google.com](https://www.google.com/chrome/). - Alternative: Use **Chromium** if you prefer an open-source version. --- ### **Installation Commands** #### **1. Install MCP (Minimal Computation Protocol)** MCP provides the framework for building agent-based automation. Install it using pip: ```bash pip install mcp ``` #### **2. Install Selenium for Browser Automation** Selenium allows programmatic interaction with web pages: ```bash pip install selenium ``` #### **3. Install WebDriver Manager (Automatically Manages ChromeDriver)** To avoid manual ChromeDriver updates, install the WebDriver Manager: ```bash pip install webdriver-manager ``` #### **4. Install Ollama for Running Local Models** Ollama is used for running LLMs locally: - **Linux/macOS (via curl)** ```bash curl -fsSL https://ollama.com/install.sh | sh ``` - **Windows (via installer)** Download and install from: [https://ollama.com/download](https://ollama.com/download) #### **5. Pull a Local LLM Model (Llama 2 Example)** Once Ollama is installed, download a model: ```bash ollama pull llama2 ``` Or use another lightweight model (faster on local machines): ```bash ollama pull mistral ``` --- ### **Verify Installations** After installing everything, verify the setup: - **Check MCP installation:** ```bash python -c "import mcp; print('MCP Installed')" ``` - **Check Selenium installation:** ```bash python -c "import selenium; print('Selenium Installed')" ``` - **Check if ChromeDriver is installed:** ```bash python -c "from selenium import webdriver; print('WebDriver Ready')" ``` - **Check Ollama model availability:** ```bash ollama list ``` This should list the downloaded models (e.g., Llama 2, Mistral). --- ### **Next Steps** Now that everything is installed, you can proceed to: - Set up the MCP server with browser automation. - Connect an MCP client to interact with the browser. - Integrate Ollama for natural language-based automation. Let me know if you need the next set of commands! 🚀

instead write the requirements.txt I would need

Here's the `requirements.txt` file you'll need for your project: ```txt mcp selenium webdriver-manager ollama ``` ### **Optional Dependencies (for Enhanced Features)** If you plan to extend functionality, consider adding: ```txt beautifulsoup4 # For parsing HTML content requests # For making HTTP requests if needed undetected-chromedriver # For bypassing bot detection (if necessary) ``` ### **Installation Command** Once you've saved `requirements.txt`, install all dependencies with: ```bash pip install -r requirements.txt ``` This will ensure your project has everything it needs to run MCP, Selenium, and Ollama locally. 🚀

write the ai_guidelines.md file for this project which will have the architecture, series of prompts to construct the project as well as instructions to use the ai_output.md file as a ledger to keep track of context being sure to include metadata in the recorded outputs by creating all of these instructions in the ai_guidelines.md for the model to follow

Here's the `ai_guidelines.md` file for your project:

The `ai_guidelines.md` file is now ready. It outlines the architecture, setup, prompt-driven development process, and usage of `ai_output.md` as a ledger for tracking AI interactions. Let me know if you need modifications or additional details! 🚀

# AI Guidelines for MCP Browser Automation Project ## Overview This document provides the architecture, construction prompts, and instructions for maintaining an AI-generated ledger (`ai_output.md`) to track project context. The project leverages MCP (Model Context Protocol) with Selenium for browser automation and a locally hosted Ollama model to facilitate AI-driven interactions. --- ## Architecture ### **Components** 1. **MCP Server (`mcp_browser_server.py`)** - Hosts tools for browser navigation. - Uses Selenium with a Chrome WebDriver. - Handles page interactions (e.g., navigation, form filling, button clicks). 2. **MCP Client (`mcp_browser_client.py`)** - Connects to the MCP server. - Issues commands to automate browser tasks. - Uses Ollama for AI-driven decision-making. 3. **Ollama Integration** - Runs a local LLM (e.g., Gemma3 or Mistral). - Processes natural language queries to automate tasks. - Augments browser interactions by making context-aware decisions. 4. **AI Output Ledger (`ai_output.md`)** - Stores AI-generated responses, metadata, and execution logs. - Tracks command history and context for reproducibility. --- Requirements.txt mcp selenium webdriver-manager ollama beautifulsoup4 requests undetected-chromedriver ### **2. Implement the MCP Server for Browser Automation** > "Generate a Python script (`mcp_browser_server.py`) that defines an MCP server with a `navigate` tool using Selenium. The tool should accept a URL, load the page, return the title, and handle exceptions gracefully." ### **3. Implement the MCP Client** > "Generate a Python script (`mcp_browser_client.py`) that connects to the MCP server, lists available tools, and calls `navigate` with a sample URL, printing the page title." ### **4. Integrate Ollama for AI-Driven Navigation** > "Modify the MCP client to use a locally hosted Ollama model to process user input and determine browser commands dynamically. Include a system prompt instructing the AI to act as an autonomous browsing assistant." ### **5. Maintain AI Context in `ai_output.md`** > "Generate a format for recording AI-generated responses in `ai_output.md`, including metadata such as timestamps, executed commands, and extracted webpage content." ### **6. Expand Browser Capabilities** > "Provide additional tools in the MCP server for filling forms, clicking buttons, and extracting page elements. Modify the client to support these interactions dynamically based on AI instructions." ### **7. Test the Workflow** > "Outline the steps to test the full pipeline: running the MCP server, executing the client with AI-driven commands, and verifying interactions via `ai_output.md`." --- ## **Instructions for Using `ai_output.md` as a Ledger** 1. **Log Every AI Interaction** - Each action executed by the AI should be recorded with: - **Timestamp** (UTC format) - **Command issued** (by AI or user) - **Execution result** (success/failure message) - **Extracted information** (page titles, form values, etc.) 2. **Include Metadata for Context Tracking** - Every entry should contain: - `session_id`: Unique identifier for an AI session. - `user_query`: Original prompt given to the AI. - `ai_response`: AI-generated command output. - `browser_state`: Captured data from Selenium (page titles, element values). 3. **Format for AI Output Entries** ``` ## Entry: YYYY-MM-DD HH:MM:SS UTC - **Session ID**: abc123xyz - **User Query**: "Navigate to example.com and extract the main heading." - **AI Response**: "Navigating to example.com... Extracting H1 tag..." - **Executed Command**: `navigate("https://example.com")` - **Browser State**: `{"page_title": "Example Domain", "h1_text": "Example Domain"}` - **Execution Status**: Success ``` 4. **Ensure Reproducibility** - Future executions should refer to previous entries to maintain context. - If an error occurs, logs should include failure reasons and retry suggestions. --- ## **Final Notes** - **Review `ai_output.md` before executing new AI-driven actions** to avoid redundant queries. - **Use clear system prompts in the MCP client** to guide AI-driven decisions effectively. - **Extend the project** by integrating additional browser actions like form submissions, scrolling, and data extraction. This structured approach ensures AI-driven Rewrite and include the ability to modify the ai_guidelines.md in order to adapt and improve the program

Here's your rewritten version with a section for modifying `ai_guidelines.md` to adapt and improve the program:

Looks like your edits went through! Let me know if you need further refinements or additional details. 🚀