> ## Documentation Index
> Fetch the complete documentation index at: https://futureagi.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Setup MCP Server

The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is a standardised protocol that enables AI models to efficiently interface with your development environment. `futureagi-mcp-server` is a server implementation using mcp which helps you to interact with Future AGI features

There are lot of MCP clients present out there which can be used to communicate with futureagi-mcp-server. You can find list of some of the clients [here](https://modelcontextprotocol.io/clients)

***

## Setup and Running

### 1. Clone the Repository

```bash theme={null}
git clone https://github.com/future-agi/futureagi-mcp-server.git
cd futureagi-mcp-server
```

### 2. Install Dependencies

```bash theme={null}
brew install uv
uv sync
```

### 3. Environment Variables

Before running the server, ensure the following environment variables are set

```bash theme={null}
export FI_API_KEY = "your_api_key"
export FI_SECRET_KEY = "your_secret_key"
```

### Running the Server

Launch the server using the main entry point:

```bash theme={null}
python main.py  #for running locally
```

***

## Integration with Clients

The server communicates using the Model Context Protocol (MCP) over standard input/output stdio channels

### To Configure with MCP Clients like VS Code and Claude Desktop using local directory

```json theme={null}
{
  "mcpServers": {
    "FutureAGI-MCP": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/futureagi-mcp-server",
        "run",
        "main.py"
      ],
      "env": {
        "FI_SECRET_KEY": "your_api_key",
        "FI_API_KEY": "your_secret_key",
        "FI_BASE_URL": "https://api.futureagi.com",
        "PYTHONPATH": "/path/to/futureagi-mcp-server"
      }
    }
  }
}
```

### A simple Configuration using uvx and published package

```json theme={null}
{
  "mcpServers": {
    "FutureAGI-MCP": {
      "command": "uvx",
      "args": [
        "futureagi-mcp-server"
      ],
      "env": {
        "FI_SECRET_KEY": "your_api_key",
        "FI_API_KEY": "your_secret_key",
      }
    }
  }
}
```

You can also add the Future AGI docs MCP to your clients by running the below command in your terminal. It will prompt you to choose the mcp clients like cursor, Claude, etc.. present on your local system. You can choose all, which will add configuration for all the mcp clients

```bash theme={null}
npx @mintlify/mcp@latest add futureagi
```

***

## Various Tools available in the server

### Evaluations

List, create, configure, and run evaluations

* `all_evaluators`: Retrieve all available evaluators, their functions, and configurations
* `get_evals_list_for_create_eval`: Fetch evaluation templates (preset or user-defined) for creating new evaluations
* `get_eval_structure`: Get detailed structure and required fields for a specific evaluation template
* `create_eval`: Create a new evaluation configuration using a template and custom settings
* `evaluate`: Run evaluations on a list of inputs against specified evaluation templates

### Datasets

Upload datasets and manage dataset configurations

* `upload_dataset`: Upload a dataset from a local file to the Future AGI platform and retrieve its configuration
* `download_dataset`: Downloads a dataset to local using name
* `get_evaluation_insights`: Get Evaluation insights for the dataset

### Protection Rules

Apply protection rules like toxicity detection, prompt injection prevention, and tone safegaurding

* `protect`: Evaluate input strings against protection rules and return status, reasons, and rule summaries

### Synthetic Data Generation

* `generate_synthetic_data`: Useful for generating synthetic data based on the dataset description and objective

***

# Usage

With **Future AGI's MCP Server**, you can do the following using natural language:

* **Run automatic evaluations** — Evaluate batch and single inputs on various [evaluation](https://docs.futureagi.com/future-agi/get-started/evaluation/running-your-first-eval) metrics present in Future AGI both on local datapoints and large datasets
* **Prototype and Observe your Agents** —  You can add [observability](https://docs.futureagi.com/future-agi/products/observe/quickstart), evaluations while both [prototyping](https://docs.futureagi.com/future-agi/get-started/prototype/overview) and deploying your agents into production using natural language
* **Manage datasets** — Upload, evaluate, download [datasets](https://docs.futureagi.com/future-agi/get-started/dataset/overview) and find insights with natural language
* **Add Protection Rules**— Apply toxicity detection, prompt injection protection, and other guardrails to your applications automatically using chat
* **Synthetic Data Generation** — Generate Synthetic Data by describing about the dataset and objective

Check out our comprehensive [blog](https://futureagi.com/blogs/model-context-protocol-mcp-2025) post on the **futureagi-mcp-server** for detailed use cases