Update README.md

README.md

@@ -49,136 +49,168 @@ The user interface is organized into clear tabs for different functions:
 
 ---
 
-## How to Use as an MCP Server for AI Agents
+## Integrating with MCP Clients
 
-This application is a fully compliant **Model Context Protocol (MCP)** server, allowing AI agents to use its functions as tools.
+This application is a fully compliant **Model Context Protocol (MCP)** server, allowing AI agents and other clients to use its functions as tools.
 
 ### Connection Endpoint
 
 The server's public endpoint is:
 `https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse`
 
-### Testing with a Public Client
+### Method 1: Test with a Public Client
 
 You can test this server immediately using this public MCP Client Space. Just paste the server URL above into the client's URL input field.
 
 **[➡️ Test with Public MCP Client](https://huggingface.co/spaces/ABDALLALSWAITI/MCPclient)**
 
-### Building Your Own Python Client (Locally)
+### Method 2: Integrate with UI Clients (e.g., Cursor IDE)
 
-You can run your own agent locally that connects to this server. Follow these steps:
+MCP hosts often use a configuration file, typically named `mcp.json`, to manage server connections [cite].
+
+#### General `mcp.json` Configuration
+
+For a remote server using HTTP+SSE transport, the configuration points to the server's URL [cite]. You would create an `mcp.json` file with the following structure:
+
+```json
+{
+  "servers": [
+    {
+      "name": "HF Info Server",
+      "transport": {
+        "type": "sse",
+        "url": "[https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse](https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse)"
+      }
+    }
+  ]
+}
+````
+
+#### Configuring Cursor IDE
+
+Cursor IDE has built-in MCP support. To connect this server, you can use the `mcp-remote` tool, which acts as a bridge for clients that don't natively support remote SSE servers [cite].
+
+1.  Open Cursor settings (`Ctrl + Shift + J` / `Cmd + Shift + J`).
+2.  Go to the `MCP` tab and click `Add new global MCP server`.
+3.  Paste the appropriate configuration below.
+
+**For macOS/Linux:**
+
+```json
+{
+  "mcpServers": {
+    "hf-info-server": {
+      "command": "npx",
+      "args": [
+        "-y", 
+        "mcp-remote", 
+        "[https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse](https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse)", 
+        "--transport", 
+        "sse-only"
+      ]
+    }
+  }
+}
+```
+
+**For Windows:**
+
+```json
+{
+  "mcpServers": {
+    "hf-info-server": {
+      "command": "cmd",
+      "args": [
+        "/c", 
+        "npx", 
+        "-y", 
+        "mcp-remote", 
+        "[https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse](https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse)", 
+        "--transport", 
+        "sse-only"
+      ]
+    }
+  }
+}
+```
+
+### Method 3: Build a Python Client with `smol-agents`
+
+You can also run your own agent locally.
 
 **1. Setup Your Environment**
 
-First, create a `requirements.txt` file for the client with the following content:
+Create a `requirements.txt` file:
 
 ```text
 gradio
 smol-agents
 litellm
-````
+```
 
-Now, set up a virtual environment and install the dependencies:
+Then, install the dependencies:
 
 ```bash
-# Create and activate a virtual environment
 python -m venv venv
 source venv/bin/activate  # On Windows use `venv\Scripts\activate`
-
-# Install the required libraries
 pip install -r requirements.txt
 ```
 
 **2. Set Your API Key**
 
-This client uses the Gemini API via LiteLLM. You need to set your Google API key as an environment variable.
-
-  - On **macOS/Linux**:
-    ```bash
-    export GOOGLE_API_KEY="YOUR_API_KEY_HERE"
-    ```
-  - On **Windows (Command Prompt)**:
-    ```bash
-    set GOOGLE_API_KEY="YOUR_API_KEY_HERE"
-    ```
+This client uses an LLM for reasoning. Export your API key as an environment variable. For example, for Google Gemini:
 
-**3. Create the Client Script**
+```bash
+export GOOGLE_API_KEY="YOUR_API_KEY_HERE"
+```
 
-Save the following code as `client_app.py`:
+**3. Create and Run the Client Script**
 
-```python
-import gradio as gr
-import os
-from smolagents import CodeAgent, MCPClient
-from smolagents import LiteLLMModel
+Save the client code from the previous section as `client_app.py` and run it:
 
-# --- Configuration ---
-# Ensure you have your GOOGLE_API_KEY set as an environment variable
-# You can get one from Google AI Studio: [https://aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey)
-API_KEY = os.getenv("GOOGLE_API_KEY")
-
-# This is the public URL of the MCP server we built.
-MCP_SERVER_URL = "[https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse](https://agents-mcp-hackathon-huggingfacedoc.hf.space/gradio_api/mcp/sse)"
-
-if not API_KEY:
-    raise ValueError("GOOGLE_API_KEY environment variable not set. Please set your API key to run this app.")
-
-# --- Main Application ---
-try:
-    print(f"🔌 Connecting to MCP Server: {MCP_SERVER_URL}")
-    mcp_client = MCPClient(
-        {"url": MCP_SERVER_URL}
-    )
-    tools = mcp_client.get_tools()
-    print(f"✅ Successfully connected. Found {len(tools)} tools.")
-
-    # We use LiteLLM to connect to the Gemini API
-    model = LiteLLMModel(
-        model_id="gemini/gemini-1.5-flash",
-        temperature=0.2,
-        api_key=API_KEY
-    )
-    
-    # The CodeAgent is effective at using tools
-    agent = CodeAgent(tools=[*tools], model=model)
-
-    # Create the Gradio ChatInterface
-    demo = gr.ChatInterface(
-        fn=lambda message, history: str(agent.run(message)),
-        title="📚 Hugging Face Research Agent",
-        description="This agent uses the Hugging Face Information Server to answer questions about models, datasets, and documentation.",
-        examples=[
-            "What is a Hugging Face pipeline?", 
-            "Find 3 popular models for text classification", 
-            "Get the info for the 'squad' dataset",
-            "What is PEFT?"
-            ],
-    )
-
-    demo.launch()
-
-finally:
-    # Ensure the connection is closed when the app stops
-    if 'mcp_client' in locals() and mcp_client.is_connected:
-        print("🔌 Disconnecting from MCP Server...")
-        mcp_client.disconnect()
+```bash
+python client_app.py
 ```
 
-**4. Run the Client App**
+-----
+
+## Advanced: Using `LiteLLMModel` Directly
+
+The `smol-agents` library uses `LiteLLMModel` to interact with various language models. If you want to use a model like Anthropic's Claude 3.5 Sonnet directly in your Python code, you can do so easily.
 
-Execute the script from your terminal:
+First, ensure you have your Anthropic API key set as an environment variable:
 
 ```bash
-python client_app.py
+export ANTHROPIC_API_KEY="YOUR_ANTHROPIC_KEY"
 ```
 
-This will launch a local Gradio interface where you can chat with an agent that uses your live MCP server.
+Then, you can use the following pattern in Python:
+
+```python
+from smolagents import LiteLLMModel
+
+# Define the messages in the standard conversation format
+messages = [
+  {"role": "user", "content": [{"type": "text", "text": "Hello, how are you?"}]}
+]
+
+# Instantiate the model
+model = LiteLLMModel(
+    model_id="anthropic/claude-3-5-sonnet-latest", 
+    temperature=0.2, 
+    max_tokens=1024
+)
+
+# Call the model with the messages
+response = model(messages)
+print(response)
+```
 
 -----
 
 ## Available Tools
 
-The server exposes the following tools to the AI agent:
+The server exposes the following tools to any connected MCP client:
 
   - `search_documentation(query, max_results)`
   - `get_model_info(model_name)`
@@ -189,23 +221,13 @@ The server exposes the following tools to the AI agent:
 
 -----
 
-## Technology Stack
-
-  - **Backend:** Python
-  - **Web UI & API:** Gradio
-  - **Data Retrieval:** Requests & BeautifulSoup
-
------
-
 ## References & Further Reading
 
   - **[Building an MCP Server with Gradio](https://huggingface.co/learn/mcp-course/unit2/gradio-server)** - A tutorial on the concepts used to build this server.
+  - **[Building MCP Clients (JS & Python)](https://huggingface.co/learn/mcp-course/unit2/clients)** - A guide on creating clients to interact with an MCP server.
 
 -----
 
 ## License
 
-This project is licensed under the Apache 2.0 License.
-
-```
-```
+This project is licensed under the Apache 2.0 License.