Evo MCP 8d3568da

MCPAI代理

提供方 SeequentEvo

AI代理 stdio · 本地进程 OAuth 授权 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

Evo MCP服务器是一个自托管服务器,通过模型上下文协议(MCP)标准为AI工具提供与Evo平台的标准化接口,支持工作区管理、地球科学对象创建等功能。

一句话选型结论

按资料字段整理

Evo MCP 8d3568da 属于AI代理类 MCP 服务器,stdio · 本地进程,OAuth 授权,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类AI代理 传输方式stdio · 本地进程 鉴权OAuth 授权 部署方式本地部署
GitHub 星标 5 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

AI代理
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

AI集成Python本地部署工作区管理地球科学数据处理模型上下文协议自托管服务

安装与配置

stdio · 本地进程 OAuth 授权
客户端在本机拉起子进程,数据不出本机
python -m venv .venv

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Python,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在AI代理场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Evo MCP 8d3568da当前 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

AI代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方SeequentEvo上游标注的维护方 SeequentEvo
分类AI代理本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Python本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

26.5 KB
来自项目仓库与上游目录的原文,未做删改

Seequent Developer Portal
• Seequent Community
• Seequent website

Evo MCP

Table of contents

  • What is MCP?
  • What is the Evo MCP server?
  • How teams use Evo MCP
  • Server architecture
  • Getting started
  • Prerequisites
  • Installation
  • Connect to Evo MCP
  • VS Code
  • Cursor
  • Additional tips
  • Advanced
  • Testing with FastMCP CLI
  • Testing with a Google ADK agent
  • Development
  • Contributing
  • Code of conduct
  • License
  • Disclaimer
  • Acknowledgements

What is MCP?

> The Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether you're building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need.
>
> — Model Context Protocol README

An MCP Server is a lightweight program that provides specific features through the Model Context Protocol standard. Applications like chatbots, code editors, and AI tools run MCP clients that each establish a direct connection with an MCP server. Popular MCP clients include agentic code assistants (such as VS Code and Cursor) and conversational tools like Claude Desktop, with more expected in the future. MCP servers can connect to both local and remote data, supplying enriched information that enables AI models to generate more accurate and useful results.

MCP servers are consumable by any MCP client such as VS Code, Claude Desktop, or a Google ADK agent.

What is the Evo MCP server?

The Evo MCP server is a self-hosted server that provides a secure, standardised interface between your AI tools and the Evo platform. It acts as a bridge, exposing Evo SDK functionality - like access to your workspaces, geoscience objects, and block models - to any AI model or agent you choose.

The server comes packaged with many tools written by Seequent, but it is fully extensible and users are encouraged to add their own tools.

How teams use Evo MCP

  • Workspace management: Create workspaces, summarize objects, snapshot and duplicate workspaces, copy objects between workspaces.
  • Geoscience object creation: structured geoscience objects (pointsets, line segments, downhole collections, and downhole intervals) in Evo directly from raw CSV files, automating data validation and schema mapping.

> [!WARNING]
> The Evo MCP server is in early development and functionality is limited. Your feedback on future development is welcome!

Server architecture```mermaid

flowchart LR
Clients["🖥️ MCP Clients<br/>VS Code · Cursor<br/>Claude Desktop · ADK"]
Clients -- "stdio / streamable HTTP" --> Server
Server -- HTTPS --> APIs

subgraph Server[&quot;Evo MCP Server (FastMCP)&quot;]
    Tools[&quot;Tool Modules&lt;br/&gt;General · Admin&lt;br/&gt;Data · Filesystem&quot;]
    Filter[MCP_TOOL_FILTER]
    Context[EvoContext&lt;br/&gt;per-session or shared]
    Proxy[&quot;OIDCProxy&lt;br/&gt;(delegated auth only)&quot;]
    Tools --&gt; Filter --&gt; Context
    Proxy -. &quot;upstream token&quot; .-&gt; Context
end

subgraph IMS[&quot;Bentley IMS&quot;]
    OIDC[OAuth 2.0 / OIDC]
end

subgraph APIs[Evo APIs]
    Discovery[Discovery]
    Workspace[Workspace]
    Object[Object]
end

Proxy -- &quot;Proxied OAuth&lt;br/&gt;(delegated)&quot; --&gt; OIDC
Context -. &quot;Direct OAuth&lt;br/&gt;(managed)&quot; .-&gt; OIDC

&gt; See docs/authentication.md for detailed sequence diagrams and session lifecycle.

### Key components

| Component | Description |
|-----------|-------------|
| **MCP clients** | Any MCP-compatible application connects to the server over `STDIO` or `streamable HTTP`. |
| **FastMCP server** | The core server runtime that handles MCP protocol, tool registration, and request routing. |
| **Tool modules** | Tools are grouped by category and conditionally registered based on the `MCP_TOOL_FILTER` setting. General tools are always loaded. |
| **EvoContext** | Manages OAuth authentication (with token caching), Evo SDK client initialization, and organization/hub selection. Initialization is lazy — it happens on the first tool call, triggering a browser-based login if needed. |
| **Evo APIs** | The Evo SDK packages (block model, geoscience object, workspace) communicate with Seequent Evo over HTTPS. |

## Getting started

### Prerequisites
- Python 3.10+
- Access to Seequent Evo (https://evo.seequent.com)

### Quick Start with Docker

**Recommended for**: Fast evaluation, containerised deployments, and users who want the easiest setup path.

1. Copy the example environment file:```bash
   cp .env.example .env
   ```
   Then fill in your auth and deployment settings in Configure your environment; `.env.example` shows the available options.
2. Start the server from the published image:```bash
   docker run --rm \
   --env-file .env \
   -e MCP_TRANSPORT=http \
   -e CLIENT_DELEGATED_AUTH=true \
   -e MCP_HTTP_HOST=0.0.0.0 \
   -e MCP_HTTP_PORT=5000 \
   -e MCP_PUBLIC_BASE_URL=http://localhost:5001 \
   -p 5001:5000 \
   ghcr.io/seequentevo/evo-mcp:latest
   ```
  Or to build from source and start with Docker Compose:```bash
   docker compose up --build
   ```
   Note: If you use the legacy Compose CLI, the equivalent command is `docker-compose up`.

3. Open `http://localhost:5001/health` to confirm the server is running.

### Installation

#### 1. Clone this repository```powershell
git clone https://github.com/SeequentEvo/evo-mcp.git

2. Navigate to the root directory```powershell

cd <path-to-this-repository>


#### 3. Create a Python environment

Option 1: Using `uv` (recommended)

The Python package manager `uv` makes it easy to set up your Python environment. Visit the uv website to learn more.

##### a. Install `uv` (if not already installed)

##### Windows```powershell
powershell -ExecutionPolicy ByPass -c &quot;irm https://astral.sh/uv/install.ps1 | iex&quot;
macOS and Linux```bash

curl -LsSf https://astral.sh/uv/install.sh | sh


##### b. Create the Python environment including dependencies```bash
uv sync

Option 2: Using pip and pyenv

If you prefer using pip and pyenv to manage your Python environment:

a. Install pyenv (if not already installed)
  • Windows: Use pyenv-win
  • macOS: brew install pyenv
  • Linux: Follow pyenv installation guide
b. Install Python 3.10+```bash

pyenv install 3.10
pyenv local 3.10
```

c. Create a virtual environment```bash

python -m venv .venv


##### d. Activate the virtual environment

##### Windows```powershell
.venv\Scripts\activate
macOS and Linux```bash

source .venv/bin/activate


##### e. Install dependencies

Install essential runtime dependencies:```bash
pip install -e .

Install dev dependencies along with the essential runtime dependencies:```bash
pip install -e '.[dev]'


#### 4. Choose an MCP transport mode (optional)

The Evo MCP server supports two common transport modes for different use cases.

##### STDIO transport (default)

**Recommended for**: VS Code, Cursor, Claude Desktop, and other integrated MCP clients

`STDIO` (Standard Input/Output) is the default transport mode and is optimised for direct integration with MCP client applications. This transport communicates through standard input and output streams, making it perfect for command-line tools and desktop applications like VS Code and Cursor.
With STDIO transport, the client spawns a new server process for each session and manages its lifecycle. The server reads MCP messages from stdin and writes responses to stdout. This is why STDIO servers don’t stay running - they’re started on-demand by the client.

**Advantages**
- Simpler configuration - client handles connection automatically
- Better performance for local connections
- Directly integrated into VS Code and Cursor workflows
- No network overhead

Configure your client (VS Code, Cursor, etc.) to start the MCP server process. The client will handle all communication via STDIO.

##### Streamable HTTP transport

**Recommended for**: Testing, remote access, programmatic access via FastMCP CLI/scripts, containerised deployments (Docker), and client-delegated shared deployments

HTTP transport turns your MCP server into a web service accessible via a URL. This transport uses the Streamable HTTP protocol, which allows clients to connect over the network. Unlike STDIO where each client gets its own process, an HTTP server can handle multiple clients simultaneously.
For the containerised path, see Quick Start with Docker section.

The Streamable HTTP protocol provides full bidirectional communication between client and server, supporting all MCP operations including streaming responses. Combined with `CLIENT_DELEGATED_AUTH=true`, HTTP transport supports multiple concurrent user sessions each authenticating with their own Bentley account.

**Advantages**
- Can be accessed via FastMCP CLI, programming languages, or HTTP clients
- Useful for testing and debugging
- Enables remote access to the server
- Simplifies integration with custom tools and scripts
- Ideal for containerised deployments (Docker, Kubernetes)
- Works well in cloud environments and microservices architectures
- Supports concurrent user sessions when `CLIENT_DELEGATED_AUTH=true`

**Limitations**
- Requires separate server process management
- Slightly higher latency due to HTTP overhead

##### Common use cases

| Use case | Recommended transport | `CLIENT_DELEGATED_AUTH` |
|----------|----------------------|-------------------|
| Using VS Code with Copilot | STDIO | `false` |
| Using Cursor with AI | STDIO | `false` |
| Using Claude Desktop | STDIO | `false` |
| Testing tools with FastMCP CLI | HTTP | `false` |
| Remote server access | HTTP | `false` |
| Custom script integration | HTTP | `false` |
| Client-delegated shared server | HTTP | `true` |
| Containerised / Docker deployment | HTTP | `true` (recommended) |

#### 5. Configure your environment

Make a copy of the file `.env.example` and rename it to `.env`. Fill in your app credentials as described below.

##### Evo app credentials
You first need to create a **native app** in the My apps page of the [Seequent Developer Portal]. This app will allow you to sign in with your Bentley account to access Seequent Evo. Visit the Seequent Developer Portal to learn more.

Fill in your app credentials in the `.env` file:```bash
EVO_CLIENT_ID=your-client-id
EVO_REDIRECT_URL=your-redirect-url

When you first use the server it will open your browser so you can sign in with your Bentley account. This gives the server access to any Evo instance and workspace your account has access to.

Alternative: Service authentication (for automation/CI)

If you need to run the server without interactive sign-in (e.g. automation, CI/CD, or background services), you can use a service app instead. Create a service app in the My apps page of the Seequent Developer Portal and set the following in your .env file:```bash
AUTH_METHOD=client_credentials
EVO_CLIENT_ID=your-service-client-id
EVO_CLIENT_SECRET=your-service-client-secret


Note: The service app must be explicitly granted access to your Evo instance and workspaces.

##### Client-delegated authentication for multi-session scenarios (optional)
When the server is running in HTTP mode, you can choose to enable client-delegated authentication to support multiple sessions with different users/identities. In this mode, each client (VS Code, Cursor, etc.) authenticates separately via OIDCProxy and holds its own token. The server maintains separate Evo sessions per client token. This is suitable for multi-user shared server scenarios where each user needs to authenticate with their own Bentley account and access their own Evo workspaces.

**Definitions**
- **Server-managed auth (default)**: The MCP server is the OAuth client. It handles authentication internally. All clients share the same Evo session and identity. Suitable for single-identity workflows where the server is only accessible to a single user or service account.
- **Client-delegated auth**: Each MCP client (VS Code, Cursor, etc.) is an independent OAuth client. Each client authenticates separately via OIDCProxy and holds its own token. The server maintains separate Evo sessions per client token. Suitable for multi-user shared server scenarios where each user needs to authenticate with their own Bentley account and access their own Evo workspaces.

The authentication flow (server-managed vs. client-delegated) is controlled by three settings: `MCP_TRANSPORT`, `AUTH_METHOD`, and `CLIENT_DELEGATED_AUTH`. The table below outlines the behaviour of the server under the valid combinations of these settings.

| `MCP_TRANSPORT` | `CLIENT_DELEGATED_AUTH` | `AUTH_METHOD` | Behaviour | Client-delegated |
|---|---|---|---|:-:|
| `stdio` | ignored | `native_app` | Server opens a browser for sign-in on first use. Token cached per process. | ❌ |
| `stdio` | ignored | `client_credentials` | Server fetches a service token automatically. No browser interaction. | ❌ |
| `http` | `false` (default) | `native_app` | Server opens a browser for sign-in on first use. All HTTP clients share the same token. | ❌ |
| `http` | `false` (default) | `client_credentials` | Server fetches a service token automatically. All HTTP clients share the same token. | ❌ |
| `http` | `true` | `native_app` | Each MCP client authenticates independently via OAuth browser flow (OIDCProxy). `AUTH_METHOD` is not used. | ✅ |

**Redirect URL configuration:**

  Based on the authentication mode, the redirect URL for OAuth will be configured differently. Ensure you set the correct redirect URL in your app configuration and the correct environment variable in your `.env` file.

  - **Server-managed auth**: ``EVO_REDIRECT_URL`` — used only in managed auth mode where the MCP server will manage the OAuth callback and token storage (e.g. ``http://localhost:3000/signin-callback``). In this mode, the hostname and port combination must be different to the ``MCP_HTTP_HOST:MCP_HTTP_PORT`` to avoid conflicts (e.g. if `MCP_HTTP_HOST=localhost` and `MCP_HTTP_PORT=5000`, use `EVO_REDIRECT_URL=http://localhost:3000/signin-callback`).

  - **Client-delegated auth**: ``OIDCPROXY_REDIRECT_PATH`` — the path on *this* MCP server where IMS sends the OAuth callback in delegated auth mode. The full url will be `http://{MCP_PUBLIC_BASE_URL}/signin-callback` (e.g. `http://localhost:5000/signin-callback` or `http://my.evo.mcp.server.com/signin-callback`).

  **Note**: MCP_PUBLIC_BASE_URL defaults to `http://{MCP_HTTP_HOST}:{MCP_HTTP_PORT}` if not set. The full redirect URL will be `http://{MCP_HTTP_HOST}:{MCP_HTTP_PORT}/signin-callback`.

##### MCP transport mode (optional)

The Evo MCP server supports two transport modes: **STDIO** and **streamable HTTP**. By default, the server runs in **STDIO** mode which is recommended for local development.

Set `MCP_TRANSPORT` environment variable in `.env` to choose the transport mode:
- `stdio` - Standard input/output (default)
- `http` - Streamable HTTP```bash
MCP_TRANSPORT=stdio

If using HTTP mode, also configure the host and port:```bash
MCP_TRANSPORT=http
MCP_HTTP_HOST=localhost
MCP_HTTP_PORT=5000


When using HTTP mode, the MCP server must be running and reachable at the configured URL. The setup scripts can start it automatically for you, or you can run it manually.

##### MCP tool filtering (optional)

Set `MCP_TOOL_FILTER` environment variable in `.env` to filter available tools:
- `admin` - Workspace/instance management and bulk data operations
- `data` - Object import, download and query operations
- `all` - All tools (default)```bash
MCP_TOOL_FILTER=all
Tool exposure strategy (optional)

Set MCP_TOOL_STRATEGY to control how the model discovers and reaches the tool catalog:
- tool-search (default) - the catalog is hidden behind two synthetic tools, search_tools and call_tool. The model searches for the tool it needs, then calls it. This keeps model-exposed toolset small and on-demand. The bootstrap tools select_instance and list_my_instances stay directly visible so an agent can always find its entry point.
- none - the full tool catalog is listed upfront (the historical behavior). Use this as an escape hatch for clients or evals that prefer a flat catalog.

When tool-search is active, MCP_SEARCH_ENGINE selects the ranking engine:
- bm25 (default) - relevance ranking over tool names and descriptions. For real agent use (fuzzy, ranked, natural-language tolerant).
- regex - pattern matching over tool names and descriptions. Deterministic, reproducible results — same query always returns the same set in the same order. Useful for tests, evals, and demos where you don't want BM25 ranking to shift.```bash
MCP_TOOL_STRATEGY=tool-search
MCP_SEARCH_ENGINE=bm25


## Connect to Evo MCP

Apps like VS Code and Cursor make it easy to connect to MCP servers, whether they are running locally, are available over a local network, or over the internet. VS Code is free to download and use. Cursor requires a paid subscription.

NOTE: Installing any of the MCP client apps described in this section is entirely optional. If you have a favourite MCP client app that you think we should document here, please create a feature request ticket and let us know.

### VS Code

#### Installation

VS Code comes in two versions - **VS Code** and **VS Code Insiders**. Install one of these apps before running Evo MCP.
NOTE: Both of these apps can be installed and used independently.

- Install the regular version of VS Code (recommended).
- Install VS Code Insiders for the most up-to-date experience. VS Code Insiders provides early access to the latest features and improvements for MCP integration.

#### Configuration

Run the supplied Python script to add the required settings. The script will ask you a series of questions in the console.

**If you set up Python with `uv`:**```bash
uv run python scripts/setup_mcp.py

If you set up Python with pip:```bash
python scripts/setup_mcp.py


**Manual method**
1. Copy the settings found in `templates/vscode-stdio-config.json`.
  - For HTTP mode, use `templates/vscode-http-config.json` instead.
  - Update the template URL host and port to match `MCP_HTTP_HOST` and `MCP_HTTP_PORT` in your `.env`, and ensure the HTTP server is running.
2. Open the **Command Palette** (press `Cmd+Shift+P` on macOS / `Ctrl+Shift+P` on Windows/Linux).
3. Search for &quot;mcp&quot;. Select **MCP: Open User Configuration** to update the user settings.

4. Paste the settings you copied from the template, update the paths to match your local installation, and save the file. NOTE: The JSON template shows Windows file paths but the screenshot below shows macOS file paths. Follow the conventions that suit your operating system.

5. The MCP server will start automatically when accessed by Copilot.

#### Verify the configuration

To verify that the Evo MCP server is correctly configured in VS Code:

1. Click the **Extensions** button in the Activity Bar (or press `Cmd+Shift+X` on macOS / `Ctrl+Shift+X` on Windows/Linux).

2. Look for **evo-mcp** in the list of **MCP Servers - Installed**.

3. Ensure there are no warning icons or error messages displayed.

If you see **evo-mcp** listed without any warnings, the configuration is correct and the server is ready to use.

### Cursor

#### Installation

Cursor is an AI-powered code editor with built-in support for MCP servers. To use the Evo MCP server in Cursor first download and install it.
NOTE: Cursor requires a paid subscription to use MCP features.

#### Configuration

Run the supplied Python script to add the required settings. The script will ask you a series of questions in the console.

**If you set up Python with `uv`:**```bash
uv run python scripts/setup_mcp.py

If you set up Python with pip:```bash
python scripts/setup_mcp.py


#### Manual method
1. Copy the settings found in `templates/cursor-stdio-config.json`.
  - For HTTP mode, use `templates/cursor-http-config.json` instead.
  - Update the template URL host and port to match `MCP_HTTP_HOST` and `MCP_HTTP_PORT` in your `.env`, and ensure the HTTP server is running.
2. Open the **Command Palette** (press `Cmd+Shift+P` on macOS / `Ctrl+Shift+P` on Windows/Linux).
3. Search for &quot;mcp&quot;. Select **View: Open MCP Settings** to update the user settings.

4. Click the **Add Custom MCP** button.

5. Paste the settings you copied from the template, update the paths to match your local installation, and save the file. NOTE: The JSON template shows Windows file paths but the screenshot below shows macOS file paths. Follow the conventions that suit your operating system.

6. The MCP server will start automatically when accessed by Cursor AI.

#### Verifying the integration

To verify that the Evo MCP server is correctly configured in Cursor:

1. Open **Settings &gt; Cursor Settings**.
2. In the search bar, type **Tools &amp; MCP**.
3. Look for **evo-mcp** in the **Installed MCP Servers** list. The MCP server should be enabled, display with a green light and list the properties of the server, eg. number of tools, etc.

### Additional tips

- **Use a separate workspace**: Create a new workspace that is separate to your clone of this repository. If your copilot/agent has access to the source files in this repository, it may decide to ignore the MCP server.
- **STDIO mode starts on demand**: In `STDIO` mode, VS Code/Cursor will launch the MCP server when needed.
- **HTTP mode needs a running server**: If you select `HTTP`, the server must already be running. The setup script can start it for you in the current terminal session so you can see live output.
- **Check your environment variables**: Ensure `EVO_CLIENT_ID` and `EVO_REDIRECT_URL` are set in your `.env` file before connecting.

- **`invalid_token` errors in delegated mode**: If you see `&quot;error&quot;: &quot;invalid_token&quot;` after the server times out waiting for authentication, the client likely holds stale tokens from a previous registration. **Resolution:** Clear your MCP client&#x27;s saved tokens/credentials for this server and reconnect — the client will re-register via DCR and obtain fresh tokens. Also verify that the redirect URI registered in your IMS application matches `{MCP_PUBLIC_BASE_URL}/signin-callback` (or your custom `OIDCPROXY_REDIRECT_PATH`). Another possible cause is the Oauth provider is temporarily unavailable or there is a network issue. If the problem persists, check  Bentley Status Page for more details or contact support.
- **Reload after changes**: If you edit settings or `.env` values, reload the window so the client picks up the new config.

---

## Advanced

### Testing with FastMCP CLI

Running Evo MCP in streamable HTTP mode allows you to use the `fastmcp` CLI to access MCP tools without manually crafting JSON-RPC payloads.

**Setup:**```bash
# In .env or environment
MCP_TRANSPORT=HTTP
MCP_HTTP_HOST=localhost
MCP_HTTP_PORT=5000

Start the server:

If you ran setup_mcp.py, selected HTTP, and chose to start now, the script starts the server in the current terminal so you can see live logs.

Otherwise, start it manually:```bash
python src/mcp_tools.py


The server will start listening on `http://localhost:5000/mcp`.

**Access tools using FastMCP CLI:**

If you installed with `uv`, run these commands as `uv run fastmcp ...`. If you installed into an active virtual environment with `pip install -e .`, run `fastmcp ...` directly instead.

For simple arguments, prefer `key=value` parameters; use `--input-json` for more complex or nested inputs.```bash
# Use either `uv run fastmcp ...` or `fastmcp ...`, depending on your installation method.

# 1) List available tools on the server
uv run fastmcp list http://localhost:5000/mcp --transport http

# 2) List workspaces
uv run fastmcp call http://localhost:5000/mcp list_workspaces \
  --transport http \
  name=&quot;&quot; \
  deleted=false \
  limit=50 \
  --json

# 3) Create a workspace
uv run fastmcp call http://localhost:5000/mcp create_workspace \
  --transport http \
  name=&quot;My New Workspace&quot; \
  description=&quot;Test workspace&quot; \
  --json

> Note: The FastMCP CLI handles MCP session setup automatically, so no manual initialize request or Mcp-Session-Id header handling is required.

Testing with a Google ADK agent

An example Google ADK agent is provided for testing the MCP server:

Prerequisites
- Google Cloud SDK (gcloud CLI) installed and configuredpowershell gcloud auth application-default login

  • A GCP project with Vertex AI API enabled

Add to .env```bash
GOOGLE_CLOUD_PROJECT=your-project-id
GOOGLE_CLOUD_LOCATION=your-region

Passed through to the MCP server's MCP_TOOL_FILTER config.

MCP_TOOL_FILTER=all


**Run**```powershell
  cd src\agents
  adk web
  ```

Browse to http://localhost:8000 to interact with the agent.

## Development

To add new MCP tools:
1. Add tool function to appropriate module in `src/evo_mcp/tools/`
2. Decorate with `@mcp.tool()` decorator
3. Tools are auto-registered based on their module (general/admin/data) on server startup
4. Test using VS Code integration or the ADK agent

### Linting

This repository uses Ruff for linting and formatting checks.
Linting also verifies that Python files include the required SPDX license header.

Run lint checks:```bash
make lint

Auto-fix lint and formatting issues:```bash
make lint-fix


### Pre-commit

Install pre-commit hooks:

The local pre-commit hook will also auto-insert missing SPDX headers in Python files.```bash
uv run --extra dev pre-commit install

Run hooks on all files:bash uv run --extra dev pre-commit run --all-files

Contributing

Thank you for your interest in contributing to Seequent software. Please have a look over our contribution guide.

Code of conduct

We rely on an open, friendly, inclusive environment. To help us ensure this remains possible, please familiarise yourself with our code of conduct.

License

The Evo MCP server is open source and licensed under the Apache 2.0 license.

Copyright © 2026 Bentley Systems, Incorporated.

Licensed under the Apache License, Version 2.0 (the "License").
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Disclaimer

Before using an MCP Server, you should consider conducting your own independent assessment to ensure that your use would comply with your own specific security and quality control practices and standards, as well as the laws, rules, and regulations that govern you and your content.

Acknowledgements

Much of this document was inspired by the excellent guides written by FastMCP and AWS Labs.

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Evo MCP 8d3568da 怎么安装?

在客户端按下面的安装命令接入:python -m venv .venv。装完在客户端配置里引用同一个包或端点。

Evo MCP 8d3568da 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Evo MCP 8d3568da 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Evo MCP 8d3568da 需要 API Key 吗?

资料标注需要OAuth 授权认证,使用前准备好对应凭据,并按最小权限配置。

Evo MCP 8d3568da 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、VS Code Insiders;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Evo MCP 8d3568da 能提供哪些能力?

资料显示能力标签包括 工作区管理、Python、VS Code。具体工具清单以官方文档为准。

Evo MCP 8d3568da 需要什么运行环境?

运行时为 Python;属于本地进程,需要在本机装好运行环境。

Evo MCP 8d3568da 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。