> For the complete documentation index, see [llms.txt](https://docs.everstake.one/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.everstake.one/integrations/everstake-products/mcp-server.md).

# MCP Server

Everstake MCP Server provides AI agents with access to Everstake staking data, infrastructure insights, and company information via the Model Context Protocol (MCP).

Built in Go using modelcontextprotocol/go-sdk, the server enables seamless integration with AI systems and developer tools.

### Overview

The Everstake MCP Server allows AI agents to:

* Retrieve company and product information
* Access live staking data (APY, uptime, supported chains)
* Use utilities like a staking calculator
* Submit integration or partnership requests

**Transport:** Streamable HTTP (MCP spec 2025-03-26)

### Available Tools

To explore them all you can visit page with [Endpoints](/integrations/everstake-products/mcp-server/endpoints.md).

The server exposes a set of MCP tools grouped into three categories:

#### Static Tools

Return predefined content:

* `get_company_profile` — company overview and key metrics
* `get_products` — product suite (Institutional Staking, VaaS, Yield, SWQOS, ShredStream)
* `get_solutions` — solutions by audience (custodians, exchanges, asset managers, etc.)
* `get_developer_docs` — SDKs, integration guides, API references
* `get_contact_information` — contact channels and routing
* `get_security_profile` — certifications (SOC 2 Type II, ISO 27001, GDPR, etc.)
* `get_integrations` — supported custody integrations (Fireblocks, BitGo, etc.)

#### Live Tools

Fetch real-time data with caching:

* `get_uptime_metrics` — uptime data (30-minute cache)
* `get_chains` — supported networks with APY, fees, and status (30-minute cache)
* `staking_calculator` — estimated staking rewards

#### Write Tools

Trigger actions:

* `request_integration` — submit a staking or integration inquiry to Everstake

### How It Works

1. An AI agent connects to the MCP server
2. The agent invokes a tool
3. The server:
   * returns a static response, or
   * fetches data from the dashboard API
4. The agent uses the response to generate output or perform actions

### Running the Server

#### Prerequisites

* Go 1.26.1+
* Required environment variable:

```
DASHBOARD_URL=https://dashboard-api.everstake.one
```

#### Run Locally

```
go run ./cmd/mcp_server
```

The server runs on port `8080` by default. You can override it with:

```
PORT=<port>
```

#### Run with Docker

```
docker build -t everstake-mcp .
docker run -e DASHBOARD_URL=https://dashboard-api.everstake.one -p 8080:8080 everstake-mcp
```

### Environment Variables

| Variable       | Required | Default |
| -------------- | -------- | ------- |
| DASHBOARD\_URL | yes      | —       |
| PORT           | no       | 8080    |
| GIN\_MODE      | no       | —       |

***

### Health Check

```
GET /health
```

### Customizing Tool Responses

#### Static Tools

Static responses are defined in `tools.yaml`.

```
tools:
  get_company_profile:
    description: |
      ...
    static_response: |
      COMPANY: Everstake
```

To add a new static tool:

1. Add a new entry in `tools.yaml`
2. Add a corresponding field to `ToolsConfig` (`internal/config/mcp_config.go`)
3. Register it in `internal/server/mcp/server.go` using `staticTextTool()`

#### Content Rules

Global content rules are defined in:

```
.vscode/tools_src/RULES.md
```

These include:

* Non-custodial positioning
* Certification messaging
* APY and product disclaimers
* Lead routing for `request_integration`

#### Dynamic Tools

Live tools:

* Fetch data from the dashboard API
* Use a 30-minute in-memory cache
* Implemented in:

```
internal/server/mcp/dashboard.go  
pkg/everstake/dashboard/
```

### Linting & Code Quality

The project uses:

* golangci-lint with strict rules

Run linting:

```
make lint
```

Includes checks such as:

* staticcheck
* gosec
* gocritic
* revive
* errchkjson
* contextcheck

### Use Cases

Everstake MCP Server can be used for:

* AI assistants in staking platforms
* Internal copilots
* LLM integrations (e.g. Claude, GPT)
* Sales and support automation

### Repository

GitHub:\
<https://github.com/everstake/mcp>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.everstake.one/integrations/everstake-products/mcp-server.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.