Erlvectordb (Modzer0)

MCP浏览器工具

提供方 Modzer0

浏览器工具 stdio · 本地进程 OAuth 授权 社区 / 第三方 Claude DesktopClaude
查看接入方式

ErlVectorDB是一个高性能的向量数据库,支持分布式集群、多种压缩算法和OAuth 2.1认证,适用于AI/ML集成和并发向量操作。

一句话选型结论

按资料字段整理

Erlvectordb (Modzer0) 属于浏览器工具类 MCP 服务器,stdio · 本地进程,OAuth 授权,可直接接入 Claude Desktop、Claude,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

HTML本地部署向量数据库分布式系统AI集成高性能存储Erlang/OTP

安装与配置

stdio · 本地进程 OAuth 授权
客户端在本机拉起子进程,数据不出本机
pip install google-generativeai

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

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

    连接成功后客户端会列出约 8 个工具,随便调一个只读工具确认能返回结果。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
自动操作网页

打开页面、点击、填表,把浏览器动作交给模型执行。

抓取结构化数据

把页面内容整理成表格或 JSON,省掉手工复制粘贴。

关键流程回归

按步骤检查页面是否正常,回归时少漏环节。

选择建议

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

值得选的地方

  • 资料标注 8 个工具,职责相对集中,接入后不容易误操作。
  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Erlvectordb (Modzer0)当前 8 stdio · 本地进程 本地部署 有 2026-05-17
Playwright MCP Server 21 stdio · 本地进程 本地部署 有 2026-05-18
Fetch 9a2682de 1 SSE · 服务端推送 支持远程部署 有 2026-05-18
Browser 738d52bc 未标注 stdio · 本地进程 本地部署 有 2026-05-17
MCP 40600ece 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Skyvern MCP 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

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

详细介绍

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

ErlVectorDB

在Erlang/OTP中实现的高性能MCP(模型上下文协议)向量数据库,旨在充分利用Actor模型和OTP监督树进行容错、并发向量操作。

特性

  • OTP原生架构:基于gen_server和监督树构建,可实现最大的容错能力
  • 分布式聚类:具有自动复制和故障转移功能的水平扩展
  • OAuth 2.1身份验证:使用客户端凭据和刷新令牌流进行安全身份验证
  • REST API:完整的REST API和MCP协议,用于web集成
  • 矢量压缩:多种压缩算法可降低存储需求
  • MCP协议支持:用于AI/ML集成的完整模型上下文协议实现
  • 永久存储:使用ETS实现基于DETS的持久化,以实现快速内存操作
  • 备份和恢复:具有JSON导出/导入的完整备份/还原功能
  • 并行矢量运算:利用Erlang的轻量级进程进行并行操作
  • 多种距离度量:余弦相似度、欧几里德距离、曼哈顿距离
  • 动态店铺管理:在运行时创建和管理多个矢量存储
  • 热代码重新加载:在不停机的情况下更新矢量操作

建筑```

erlvectordb_sup (Main Supervisor)
├── cluster_manager (Distributed Clustering)
├── oauth_server (OAuth 2.1 Authentication Server)
├── oauth_http_handler (OAuth HTTP Endpoints)
├── rest_api_server (REST API Server)
├── vector_store_sup (Dynamic Supervisor for Vector Stores)
│ ├── vector_store (Gen Server per store)
│ │ └── vector_persistence (DETS + ETS + Compression)
│ └── vector_store (Gen Server per store)
│ └── vector_persistence (DETS + ETS + Compression)
├── mcp_server (MCP Protocol Handler with OAuth)
└── vector_index_manager (Index Management)


## 快速开始

> 🚀 **ErlVectorDB新手?** 看看 快速入门指南 只需5分钟的设置!

### 先决条件

- Erlang/OTP 24+
- 钢筋3

### 建筑```bash
rebar3 compile

跑步```bash

Quick start with automatic setup

./start-local.sh

Or manually

rebar3 shell


### 管理服务器```bash
# Check server status
./check-status.sh

# Stop the server and cleanup
./stop-server.sh

# Run automated test suite
./test_server.sh

测试```bash

Run automated test suite

./test_server.sh

Run Common Test suites

rebar3 ct


### 基本用法```erlang
% Start the application
erlvectordb:start().

% Register OAuth client (optional - default admin client is created)
erlvectordb:register_oauth_client(<<"my_client">>, <<"my_secret">>, #{
scopes => [<<"read">>, <<"write">>]
}).

% Get OAuth access token
{ok, TokenResponse} = erlvectordb:get_oauth_token(<<"admin">>, <<"admin_secret_2024">>, [<<"read">>, <<"write">>]).
AccessToken = maps:get(access_token, TokenResponse).

% Create a regular vector store
erlvectordb:create_store(my_store).

% Create a distributed vector store (if clustering enabled)
erlvectordb:create_distributed_store(distributed_store, #{replication_factor => 2}).

% Insert vectors (with automatic compression if enabled)
Vector1 = [1.0, 2.0, 3.0],
erlvectordb:insert(my_store, <<"doc1">>, Vector1, #{title => "Document 1"}).

% Insert with explicit compression
erlvectordb:insert_compressed(my_store, <<"doc2">>, [2.0, 3.0, 4.0], #{title => "Document 2"}).

% Search for similar vectors
QueryVector = [1.1, 2.1, 3.1],
{ok, Results} = erlvectordb:search(my_store, QueryVector, 5).

% Get store statistics
{ok, Stats} = erlvectordb:get_stats(my_store).

% Benchmark compression algorithms
Algorithms = [quantization_8bit, quantization_4bit, zlib_compression],
BenchmarkResults = erlvectordb:benchmark_compression([1.0, 2.0, 3.0, 4.0], Algorithms).

% Clustering operations
erlvectordb:join_cluster('other_node@hostname').
{ok, ClusterStatus} = erlvectordb:get_cluster_status().

分布式聚类

设置群集

在配置中启用群集:```erlang
{cluster_enabled, true},
{node_name, 'erlvectordb@node1.example.com'},
{cluster_cookie, my_secure_cookie},
{replication_factor, 2}


### 集群操作```erlang
% Join an existing cluster
erlvectordb:join_cluster('erlvectordb@node2.example.com').

% Create distributed stores
erlvectordb:create_distributed_store(my_distributed_store, #{
replication_factor => 3
}).

% Check cluster status
{ok, Status} = erlvectordb:get_cluster_status().

% Leave cluster
erlvectordb:leave_cluster().

自动功能

  • 复制:矢量在节点间自动复制
  • 故障转移:节点停机时自动故障转移
  • 负载平衡:跨可用副本分布的查询
  • 一致性:最终符合冲突解决

矢量压缩

支持的算法

  • 8位量化:将精度降低到每维8位
  • 4位量化:将精度降低到每维4位
  • PCA压缩:主成分分析降维
  • Zlib压缩:通用压缩
  • 产品量化:大矢量的子矢量量化

压缩使用情况```erlang

% Enable compression globally
application:set_env(erlvectordb, compression_enabled, true).
application:set_env(erlvectordb, compression_algorithm, quantization_8bit).

% Compress specific vectors
{ok, Compressed} = erlvectordb:compress_vector([1.0, 2.0, 3.0], quantization_8bit).

% Benchmark compression algorithms
Vector = lists:seq(1.0, 100.0, 1.0),
Algorithms = [quantization_8bit, quantization_4bit, zlib_compression],
Results = erlvectordb:benchmark_compression(Vector, Algorithms).

% Results include compression_ratio, compression_time, decompression_time, accuracy_loss


### 压缩优势

- **存储减少**:根据算法节省50-90%的存储空间
- **网络效率**:更快的复制和备份操作
- **内存使用**:减少大型数据集的RAM需求
- **可配置的权衡**:压缩比和精度之间的平衡

## REST API

该系统提供了一个完整的REST API和MCP协议:

### 端点

**店铺管理:**

- `POST /api/v1/stores` -创建商店
- `GET /api/v1/stores` -列出商店
- `DELETE /api/v1/stores/{name}` -删除商店

**矢量操作:**

- `POST /api/v1/stores/{name}/vectors` -插入向量
- `POST /api/v1/stores/{name}/search` -搜索向量
- `GET /api/v1/stores/{name}/stats` -获取店铺统计信息

**集群管理:**

- `GET /api/v1/cluster/status` -集群状态
- `POST /api/v1/cluster/join` -加入集群

### REST API示例```bash
# Get OAuth token
curl -X POST http://localhost:8081/oauth/token \
-d "grant_type=client_credentials&client_id=admin&client_secret=admin_secret_2024&scope=read write"

# Create store
curl -X POST http://localhost:8082/api/v1/stores \
-H "Authorization: Bearer YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"name": "my_store"}'

# Insert vector
curl -X POST http://localhost:8082/api/v1/stores/my_store/vectors \
-H "Authorization: Bearer YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"id": "doc1", "vector": [1.0, 2.0, 3.0], "metadata": {"title": "Document 1"}}'

# Search vectors
curl -X POST http://localhost:8082/api/v1/stores/my_store/search \
-H "Authorization: Bearer YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"vector": [1.1, 2.1, 3.1], "k": 5}'

OAuth 2.1身份验证

默认凭据

系统在启动时创建默认的管理客户端:

  • 客户端ID: admin
  • 客户端密钥: admin_secret_2024
  • 范围: read, write, admin

获取访问令牌

使用Erlang API:```erlang

{ok, TokenResponse} = erlvectordb:get_oauth_token(
<<"admin">>,
<<"admin_secret_2024">>,
[<<"read">>, <<"write">>]
).
AccessToken = maps:get(access_token, TokenResponse).


#### 使用HTTP API:```bash
curl -X POST http://localhost:8081/oauth/token \
-H &quot;Content-Type: application/x-www-form-urlencoded&quot; \
-d &quot;grant_type=client_credentials&amp;client_id=admin&amp;client_secret=admin_secret_2024&amp;scope=read write&quot;

注册新客户```erlang

erlvectordb:register_oauth_client(<<"my_app">>, <<"secure_secret">>, #{
scopes => [<<"read">>, <<"write">>],
grant_types => [<<"client_credentials">>, <<"refresh_token">>]
}).


### 基于范围的权限

- **`read`**:搜索向量,获取统计信息
- **`write`**:插入/删除向量,同步存储
- **`admin`**:备份/还原操作、客户端管理

## AI集成

### Gemini AI集成

ErlVectorDB包括使用谷歌Gemini AI进行语义搜索和智能文档分析的AI功能:```bash
# Setup Gemini integration
export GEMINI_API_KEY=&#x27;your-gemini-api-key&#x27;
pip install google-generativeai
bash examples/setup_gemini_demo.sh

# Run AI-enhanced demo
python examples/gemini_mcp_client.py

AI功能:

  • 语义嵌入:使用Gemini AI生成向量嵌入
  • 智能文档分析:自动分类和元数据提取
  • 智能搜索:带有AI解释的自然语言查询
  • 内容理解:情感分析和主题提取

示例用法:```python
from examples.gemini_mcp_client import GeminiMCPClient

client = GeminiMCPClient(gemini_api_key="your-key")
client.connect_to_vectordb()

AI-powered document insertion with automatic analysis

result = client.smart_insert('ai_store', 'healthcare_doc',
'AI is revolutionizing medical diagnosis and treatment...')

Semantic search with natural language

search = client.smart_search('medical AI applications', 'ai_store')
print(search['explanation']) # AI explains why results are relevant


### Gemini CLI配置

要将ErlVectorDB与Gemini CLI一起使用,您需要将其配置为MCP服务器。

#### 步骤1:获取Gemini API密钥

从以下位置获取API密钥:https://makersuite.google.com/app/apikey

#### 步骤2:配置Gemini CLI

创建或编辑Gemini CLI配置文件:

**位置**: `~/.config/gemini-cli/config.json` (Linux/macOS)或 `%USERPROFILE%\.config\gemini-cli\config.json` (Windows)```json
{
&quot;mcpServers&quot;: {
&quot;erlvectordb&quot;: {
&quot;command&quot;: &quot;python&quot;,
&quot;args&quot;: [&quot;/path/to/Erlvectordb/examples/gemini_mcp_server.py&quot;],
&quot;env&quot;: {
&quot;ERLVECTORDB_HOST&quot;: &quot;localhost&quot;,
&quot;ERLVECTORDB_PORT&quot;: &quot;8080&quot;,
&quot;ERLVECTORDB_OAUTH_HOST&quot;: &quot;localhost&quot;,
&quot;ERLVECTORDB_OAUTH_PORT&quot;: &quot;8081&quot;,
&quot;ERLVECTORDB_CLIENT_ID&quot;: &quot;admin&quot;,
&quot;ERLVECTORDB_CLIENT_SECRET&quot;: &quot;admin_secret_2024&quot;
}
}
}
}

重要:替换 /path/to/Erlvectordb 使用ErlVectorDB安装的实际路径。

有关详细的配置选项,请参阅 Gemini MCP服务器配置指南.

步骤3:启动ErlVectorDB```bash

Using the local starter script (recommended)

./start-local.sh

Or manually

rebar3 shell --eval "application:ensure_all_started(erlvectordb)"


#### 步骤4:与Gemini CLI一起使用```bash
# Start Gemini CLI
gemini-cli

# The ErlVectorDB MCP server will be automatically available
# You can now use natural language to interact with your vector database:

&gt; &quot;Store this document about machine learning in the database&quot;
&gt; &quot;Find similar documents about AI&quot;
&gt; &quot;What documents do I have about healthcare?&quot;

Gemini CLI连接故障排除

如果出现“连接关闭”错误:

  1. 验证ErlVectorDB是否正在运行:```bash
    ./check-status.sh

1. **直接测试MCP服务器**:```bash
echo &#x27;{&quot;jsonrpc&quot;:&quot;2.0&quot;,&quot;method&quot;:&quot;initialize&quot;,&quot;id&quot;:1,&quot;params&quot;:{}}&#x27; | \
python examples/gemini_mcp_server.py
  1. 检查日志:
    MCP服务器登录到stderr,因此您可以在Gemini CLI输出中看到错误。

  2. 验证配置中的路径:
    确保路径 gemini_mcp_server.py 是绝对和正确的。

  3. 测试OAuth连接:```bash
    curl -X POST http://localhost:8081/oauth/token \
    -d "grant_type=client_credentials&client_id=admin&client_secret=admin_secret_2024&scope=read write"


1. **检查Python依赖关系**:```bash
python3 -c &quot;import requests; print(&#x27;requests OK&#x27;)&quot;
  1. 启用调试日志记录:```bash
    export ERLVECTORDB_LOG_LEVEL=DEBUG
    python examples/gemini_mcp_server.py

#### Gemini MCP服务器常见问题

**问题:“连接超时”**

- 症状:服务器无法连接到ErlVectorDB
- 解决方案:增加环境变量中的超时时间:```bash
export ERLVECTORDB_SOCKET_TIMEOUT=60

问题:“身份验证错误”

  • 症状:OAuth令牌获取失败
  • 解决方案:验证OAuth服务器是否正在运行以及凭据是否正确:```bash

Check OAuth server

curl http://localhost:8081/oauth/token \
-d "grant_type=client_credentials&client_id=admin&client_secret=admin_secret_2024&scope=read write"


**问题:“解析错误”**

- 症状:JSON解析失败
- 解决方案:确保请求格式正确,为带换行符的单行JSON

**问题:“远程主机关闭连接”**

- 症状:ErlVectorDB意外关闭连接
- 解决方案:检查ErlVectorDB日志是否有错误,验证网络连接

**问题:“消息不完整”**

- 症状:大反应被截断
- 解决方案:增加缓冲区大小:```bash
export ERLVECTORDB_BUFFER_SIZE=16384

Gemini MCP服务器配置选项

这 gemini_mcp_server.py 脚本支持以下环境变量:

连接设置:

  • ERLVECTORDB_HOST -MCP服务器主机(默认:localhost)
  • ERLVECTORDB_PORT -MCP服务器端口(默认值:8080)
  • ERLVECTORDB_OAUTH_HOST -OAuth服务器主机(默认:localhost)
  • ERLVECTORDB_OAUTH_PORT -OAuth服务器端口(默认:8081)

身份验证:

  • ERLVECTORDB_CLIENT_ID -OAuth客户端ID(默认值:admin)
  • ERLVECTORDB_CLIENT_SECRET -OAuth客户端密钥(默认:admin_secret_2024)

插座配置:

  • ERLVECTORDB_SOCKET_TIMEOUT -套接字超时(秒)(默认值:30)
  • ERLVECTORDB_BUFFER_SIZE -套接字缓冲区大小(字节)(默认值:8192)

重新连接设置:

  • ERLVECTORDB_MAX_RECONNECT_ATTEMPTS -最大重新连接尝试次数(默认值:3)
  • ERLVECTORDB_RECONNECT_DELAY -初始重新连接延迟(秒)(默认值:1.0)

OAuth重试设置:

  • ERLVECTORDB_OAUTH_MAX_RETRIES -OAuth令牌请求重试次数上限(默认值:3)
  • ERLVECTORDB_OAUTH_INITIAL_BACKOFF -初始退避延迟(秒)(默认值:1.0)
  • ERLVECTORDB_OAUTH_MAX_BACKOFF -最大退避延迟(秒)(默认值:30.0)
  • ERLVECTORDB_OAUTH_BACKOFF_MULTIPLIER -回退倍数(默认值:2.0)

登录中:

  • ERLVECTORDB_LOG_LEVEL -日志级别:调试、信息、警告、错误、严重(默认值:信息)

配置示例:```bash

High-latency network configuration

export ERLVECTORDB_SOCKET_TIMEOUT=60
export ERLVECTORDB_MAX_RECONNECT_ATTEMPTS=5
export ERLVECTORDB_RECONNECT_DELAY=2.0

Large message handling

export ERLVECTORDB_BUFFER_SIZE=32768

Debug mode

export ERLVECTORDB_LOG_LEVEL=DEBUG

Run server

python examples/gemini_mcp_server.py


#### Gemini MCP服务器使用示例

**Gemini CLI的基本用法:**

配置后,您可以在Gemini CLI中使用自然语言:```bash
# Start Gemini CLI
gemini-cli

# Example interactions:
&gt; &quot;Create a vector store called &#x27;documents&#x27;&quot;
&gt; &quot;Insert a vector [1.0, 2.0, 3.0] with id &#x27;doc1&#x27; into the documents store&quot;
&gt; &quot;Search for vectors similar to [1.1, 2.1, 3.1] in the documents store&quot;
&gt; &quot;List all available tools&quot;

直接测试(无Gemini CLI):

直接通过stdin/stdout测试MCP服务器:```bash

Test initialize

echo '{"jsonrpc":"2.0","method":"initialize","id":1,"params":{"protocolVersion":"2024-11-05","capabilities":{"tools":{}}}}' | \
python examples/gemini_mcp_server.py

Test tools/list

echo '{"jsonrpc":"2.0","method":"tools/list","id":2,"params":{}}' | \
python examples/gemini_mcp_server.py

Test tools/call

echo '{"jsonrpc":"2.0","method":"tools/call","id":3,"params":{"name":"create_store","arguments":{"name":"test_store"}}}' | \
python examples/gemini_mcp_server.py


**程序化使用:**

在您自己的Python代码中使用服务器组件:```python
from examples.gemini_mcp_server import MCPServer, ServerConfig

# Create configuration
config = ServerConfig.from_environment()

# Or customize configuration
config = ServerConfig(
erlvectordb_host=&#x27;localhost&#x27;,
erlvectordb_port=8080,
oauth_host=&#x27;localhost&#x27;,
oauth_port=8081,
client_id=&#x27;admin&#x27;,
client_secret=&#x27;admin_secret_2024&#x27;,
socket_timeout=60,
log_level=&#x27;DEBUG&#x27;
)

# Validate configuration
config.validate()

# Create and run server
server = MCPServer(config)
exit_code = server.run()

组件级别使用:

使用单个组件进行自定义集成:```python
from examples.gemini_mcp_server import (
SocketHandler, OAuthManager, RequestRouter,
StdioHandler, ServerConfig
)

Create configuration

config = ServerConfig.from_environment()

OAuth token management

oauth_manager = OAuthManager(config)
token = oauth_manager.get_token()
print(f"Access token: {token}")

Socket communication

socket_handler = SocketHandler(
host=config.erlvectordb_host,
port=config.erlvectordb_port
)
socket_handler.connect()

Send request

request = {
'jsonrpc': '2.0',
'method': 'tools/list',
'params': {},
'id': 1,
'auth': oauth_manager.get_auth_dict()
}
socket_handler.send_message(request)
response = socket_handler.receive_message()
print(f"Response: {response}")

Cleanup

socket_handler.close()


#### 替代方案:直接Python脚本

如果你更喜欢直接使用Python客户端进行演示:```bash
# Set environment variables
export GEMINI_API_KEY=&#x27;your-gemini-api-key&#x27;
export ERLVECTORDB_HOST=&#x27;localhost&#x27;
export ERLVECTORDB_PORT=&#x27;8080&#x27;
export ERLVECTORDB_OAUTH_HOST=&#x27;localhost&#x27;
export ERLVECTORDB_OAUTH_PORT=&#x27;8081&#x27;
export ERLVECTORDB_CLIENT_ID=&#x27;admin&#x27;
export ERLVECTORDB_CLIENT_SECRET=&#x27;admin_secret_2024&#x27;

# Run the demo client (not for Gemini CLI)
python examples/gemini_mcp_client.py

Claude桌面集成:```json
{
"mcpServers": {
"erlvectordb-ai": {
"command": "python",
"args": ["examples/gemini_mcp_client.py"],
"env": {
"GEMINI_API_KEY": "${GEMINI_API_KEY}",
"ERLVECTORDB_HOST": "localhost",
"ERLVECTORDB_PORT": "8080"
}
}
}
}


## MCP集成

该数据库在端口8080(可配置)上公开了一个具有OAuth 2.1身份验证的MCP服务器。OAuth服务器在端口8081上运行。

&gt; 📖 **详细设置指南**:参见 MCP设置指南 获取完整的配置和连接说明。

### 快速MCP设置

1. **启动ErlVectorDB**:```bash
rebar3 shell
  1. 测试连接:```bash

Get OAuth token

curl -X POST http://localhost:8081/oauth/token \
-d "grant_type=client_credentials&client_id=admin&client_secret=admin_secret_2024&scope=read write"

Test MCP connection

telnet localhost 8080


1. **运行示例客户端**:```bash
node examples/mcp_client.js
# or
python examples/mcp_client.py
# or AI-enhanced with Gemini
export GEMINI_API_KEY=&#x27;your-key&#x27;
python examples/gemini_mcp_client.py

MCP服务器配置

基本配置```erlang

% In config/sys.config
[
{erlvectordb, [
{mcp_port, 8080}, % MCP server port
{oauth_enabled, true}, % Enable OAuth authentication
{oauth_port, 8081}, % OAuth server port
% ... other settings
]}
].


#### 禁用身份验证(仅限开发)```erlang
{oauth_enabled, false}  % Disables OAuth - NOT recommended for production

MCP客户端配置

适用于克劳德桌面

添加到您的Claude Desktop配置文件中:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
视窗: `%APPDATA%\Claude\claude_desktop_config.json````json
{
"mcpServers": {
"erlvectordb": {
"command": "node",
"args": ["/path/to/mcp-client.js"],
"env": {
"ERLVECTORDB_HOST": "localhost",
"ERLVECTORDB_PORT": "8080",
"ERLVECTORDB_OAUTH_HOST": "localhost",
"ERLVECTORDB_OAUTH_PORT": "8081",
"ERLVECTORDB_CLIENT_ID": "admin",
"ERLVECTORDB_CLIENT_SECRET": "admin_secret_2024"
}
}
}
}


#### 对于其他MCP客户端

配置您的MCP客户端以连接到:

- **MCP端点**: `tcp://localhost:8080`
- **OAuth端点**: `http://localhost:8081/oauth/token`

### MCP客户端实现

以下是一个完整的Node.js MCP客户端示例:```javascript
// mcp-client.js
const net = require(&#x27;net&#x27;);
const https = require(&#x27;https&#x27;);

class ErlVectorDBClient {
constructor(options = {}) {
this.host = options.host || &#x27;localhost&#x27;;
this.port = options.port || 8080;
this.oauthHost = options.oauthHost || &#x27;localhost&#x27;;
this.oauthPort = options.oauthPort || 8081;
this.clientId = options.clientId || &#x27;admin&#x27;;
this.clientSecret = options.clientSecret || &#x27;admin_secret_2024&#x27;;
this.accessToken = null;
this.socket = null;
}

async getAccessToken() {
const postData = new URLSearchParams({
grant_type: &#x27;client_credentials&#x27;,
client_id: this.clientId,
client_secret: this.clientSecret,
scope: &#x27;read write admin&#x27;
}).toString();

const options = {
hostname: this.oauthHost,
port: this.oauthPort,
path: &#x27;/oauth/token&#x27;,
method: &#x27;POST&#x27;,
headers: {
&#x27;Content-Type&#x27;: &#x27;application/x-www-form-urlencoded&#x27;,
&#x27;Content-Length&#x27;: Buffer.byteLength(postData)
}
};

return new Promise((resolve, reject) =&gt; {
const req = http.request(options, (res) =&gt; {
let data = &#x27;&#x27;;
res.on(&#x27;data&#x27;, (chunk) =&gt; data += chunk);
res.on(&#x27;end&#x27;, () =&gt; {
try {
const response = JSON.parse(data);
if (response.access_token) {
this.accessToken = response.access_token;
resolve(response.access_token);
} else {
reject(new Error(&#x27;No access token received&#x27;));
}
} catch (error) {
reject(error);
}
});
});

req.on(&#x27;error&#x27;, reject);
req.write(postData);
req.end();
});
}

async connect() {
if (!this.accessToken) {
await this.getAccessToken();
}

return new Promise((resolve, reject) =&gt; {
this.socket = net.createConnection(this.port, this.host, () =&gt; {
console.log(&#x27;Connected to ErlVectorDB MCP server&#x27;);
resolve();
});

this.socket.on(&#x27;error&#x27;, reject);
this.socket.on(&#x27;data&#x27;, (data) =&gt; {
try {
const response = JSON.parse(data.toString());
this.handleResponse(response);
} catch (error) {
console.error(&#x27;Failed to parse response:&#x27;, error);
}
});
});
}

async sendRequest(method, params = {}, id = 1) {
const request = {
jsonrpc: &#x27;2.0&#x27;,
method: method,
params: params,
id: id,
auth: {
type: &#x27;bearer&#x27;,
token: this.accessToken
}
};

return new Promise((resolve, reject) =&gt; {
this.responseHandlers = this.responseHandlers || {};
this.responseHandlers[id] = { resolve, reject };

const requestData = JSON.stringify(request);
this.socket.write(requestData);
});
}

handleResponse(response) {
if (response.id &amp;&amp; this.responseHandlers[response.id]) {
const handler = this.responseHandlers[response.id];
delete this.responseHandlers[response.id];

if (response.error) {
handler.reject(new Error(response.error.message));
} else {
handler.resolve(response.result);
}
}
}

// MCP Protocol Methods
async initialize() {
return this.sendRequest(&#x27;initialize&#x27;, {
protocolVersion: &#x27;2024-11-05&#x27;,
capabilities: {
tools: {}
},
clientInfo: {
name: &#x27;erlvectordb-client&#x27;,
version: &#x27;1.0.0&#x27;
}
});
}

async listTools() {
return this.sendRequest(&#x27;tools/list&#x27;);
}

async callTool(name, arguments) {
return this.sendRequest(&#x27;tools/call&#x27;, {
name: name,
arguments: arguments
});
}

// Vector Database Operations
async createStore(name) {
return this.callTool(&#x27;create_store&#x27;, { name: name });
}

async insertVector(store, id, vector, metadata = {}) {
return this.callTool(&#x27;insert_vector&#x27;, {
store: store,
id: id,
vector: vector,
metadata: metadata
});
}

async searchVectors(store, vector, k = 10) {
return this.callTool(&#x27;search_vectors&#x27;, {
store: store,
vector: vector,
k: k
});
}

async syncStore(store) {
return this.callTool(&#x27;sync_store&#x27;, { store: store });
}

async backupStore(store, backupName) {
return this.callTool(&#x27;backup_store&#x27;, {
store: store,
backup_name: backupName
});
}

async listBackups() {
return this.callTool(&#x27;list_backups&#x27;, {});
}

disconnect() {
if (this.socket) {
this.socket.end();
this.socket = null;
}
}
}

// Usage Example
async function main() {
const client = new ErlVectorDBClient({
host: process.env.ERLVECTORDB_HOST || &#x27;localhost&#x27;,
port: parseInt(process.env.ERLVECTORDB_PORT) || 8080,
oauthHost: process.env.ERLVECTORDB_OAUTH_HOST || &#x27;localhost&#x27;,
oauthPort: parseInt(process.env.ERLVECTORDB_OAUTH_PORT) || 8081,
clientId: process.env.ERLVECTORDB_CLIENT_ID || &#x27;admin&#x27;,
clientSecret: process.env.ERLVECTORDB_CLIENT_SECRET || &#x27;admin_secret_2024&#x27;
});

try {
await client.connect();
await client.initialize();

const tools = await client.listTools();
console.log(&#x27;Available tools:&#x27;, tools);

// Create a store
await client.createStore(&#x27;test_store&#x27;);

// Insert a vector
await client.insertVector(&#x27;test_store&#x27;, &#x27;doc1&#x27;, [1.0, 2.0, 3.0], {
title: &#x27;Test Document&#x27;
});

// Search for similar vectors
const results = await client.searchVectors(&#x27;test_store&#x27;, [1.1, 2.1, 3.1], 5);
console.log(&#x27;Search results:&#x27;, results);

} catch (error) {
console.error(&#x27;Error:&#x27;, error);
} finally {
client.disconnect();
}
}

if (require.main === module) {
main();
}

module.exports = ErlVectorDBClient;

Python MCP客户端```python

mcp_client.py

import json
import socket
import requests
from typing import Dict, List, Any, Optional

class ErlVectorDBClient:
def init(self, host='localhost', port=8080, oauth_host='localhost',
oauth_port=8081, client_id='admin', client_secret='admin_secret_2024'):
self.host = host
self.port = port
self.oauth_host = oauth_host
self.oauth_port = oauth_port
self.client_id = client_id
self.client_secret = client_secret
self.access_token = None
self.socket = None
self.request_id = 1

def get_access_token(self) -> str:
"""Get OAuth access token"""
url = f'http://{self.oauth_host}:{self.oauth_port}/oauth/token'
data = {
'grant_type': 'client_credentials',
'client_id': self.client_id,
'client_secret': self.client_secret,
'scope': 'read write admin'
}

response = requests.post(url, data=data)
response.raise_for_status()

token_data = response.json()
self.access_token = token_data['access_token']
return self.access_token

def connect(self):
"""Connect to MCP server"""
if not self.access_token:
self.get_access_token()

self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((self.host, self.port))

def send_request(self, method: str, params: Dict = None, request_id: int = None) -> Dict:
"""Send MCP request"""
if request_id is None:
request_id = self.request_id
self.request_id += 1

request = {
'jsonrpc': '2.0',
'method': method,
'params': params or {},
'id': request_id,
'auth': {
'type': 'bearer',
'token': self.access_token
}
}

request_data = json.dumps(request).encode('utf-8')
self.socket.send(request_data)

Receive response

response_data = self.socket.recv(4096)
response = json.loads(response_data.decode('utf-8'))

if 'error' in response:
raise Exception(f"MCP Error: {response['error']['message']}")

return response.get('result', {})

def initialize(self) -> Dict:
"""Initialize MCP connection"""
return self.send_request('initialize', {
'protocolVersion': '2024-11-05',
'capabilities': {'tools': {}},
'clientInfo': {
'name': 'erlvectordb-python-client',
'version': '1.0.0'
}
})

def list_tools(self) -> Dict:
"""List available tools"""
return self.send_request('tools/list')

def call_tool(self, name: str, arguments: Dict) -> Dict:
"""Call a specific tool"""
return self.send_request('tools/call', {
'name': name,
'arguments': arguments
})

Vector Database Operations

def create_store(self, name: str) -> Dict:
return self.call_tool('create_store', {'name': name})

def insert_vector(self, store: str, vector_id: str, vector: List[float],
metadata: Dict = None) -> Dict:
return self.call_tool('insert_vector', {
'store': store,
'id': vector_id,
'vector': vector,
'metadata': metadata or {}
})

def search_vectors(self, store: str, vector: List[float], k: int = 10) -> Dict:
return self.call_tool('search_vectors', {
'store': store,
'vector': vector,
'k': k
})

def sync_store(self, store: str) -> Dict:
return self.call_tool('sync_store', {'store': store})

def backup_store(self, store: str, backup_name: str) -> Dict:
return self.call_tool('backup_store', {
'store': store,
'backup_name': backup_name
})

def list_backups(self) -> Dict:
return self.call_tool('list_backups', {})

def disconnect(self):
"""Disconnect from server"""
if self.socket:
self.socket.close()
self.socket = None

Usage Example

if name == 'main':
client = ErlVectorDBClient()

try:
client.connect()
client.initialize()

List available tools

tools = client.list_tools()
print('Available tools:', tools)

Create a store

client.create_store('python_test_store')

Insert vectors

client.insert_vector('python_test_store', 'doc1', [1.0, 2.0, 3.0],
{'title': 'Python Test Document'})

Search

results = client.search_vectors('python_test_store', [1.1, 2.1, 3.1], 5)
print('Search results:', results)

except Exception as e:
print(f'Error: {e}')
finally:
client.disconnect()


### 可用工具(按范围):

**读取范围:**

- `search_vectors`:搜索相似向量

**写入范围:**

- `create_store`:创建新的矢量存储
- `insert_vector`:插入包含元数据的向量
- `sync_store`:将存储同步到持久存储

**管理范围:**

- `backup_store`:创建存储的备份
- `restore_store`:从备份还原存储
- `list_backups`:列出所有可用备份

### 使用OAuth的MCP客户端示例```json
{
&quot;jsonrpc&quot;: &quot;2.0&quot;,
&quot;method&quot;: &quot;tools/call&quot;,
&quot;params&quot;: {
&quot;name&quot;: &quot;insert_vector&quot;,
&quot;arguments&quot;: {
&quot;store&quot;: &quot;my_store&quot;,
&quot;id&quot;: &quot;doc1&quot;,
&quot;vector&quot;: [1.0, 2.0, 3.0],
&quot;metadata&quot;: {&quot;title&quot;: &quot;Document 1&quot;}
}
},
&quot;auth&quot;: {
&quot;type&quot;: &quot;bearer&quot;,
&quot;token&quot;: &quot;your_access_token_here&quot;
},
&quot;id&quot;: 1
}

MCP连接测试

测试OAuth连接```bash

Test OAuth token endpoint

curl -X POST http://localhost:8081/oauth/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=client_credentials&client_id=admin&client_secret=admin_secret_2024&scope=read write admin"


#### 测试MCP连接```bash
# Test MCP server connectivity
telnet localhost 8080

# Send initialize request (after connecting)
{&quot;jsonrpc&quot;:&quot;2.0&quot;,&quot;method&quot;:&quot;initialize&quot;,&quot;params&quot;:{&quot;protocolVersion&quot;:&quot;2024-11-05&quot;,&quot;capabilities&quot;:{&quot;tools&quot;:{}}},&quot;id&quot;:1}

MCP集成模式

流媒体响应

对于大型结果集,实现流式传输:```javascript
// Handle streaming responses
client.socket.on('data', (chunk) => {
const lines = chunk.toString().split('\n');
lines.forEach(line => {
if (line.trim()) {
try {
const response = JSON.parse(line);
handleStreamingResponse(response);
} catch (e) {
// Handle partial JSON
buffer += line;
}
}
});
});


#### 连接池

对于高通量应用:```javascript
class ErlVectorDBPool {
constructor(options, poolSize = 5) {
this.options = options;
this.poolSize = poolSize;
this.connections = [];
this.available = [];
}

async getConnection() {
if (this.available.length &gt; 0) {
return this.available.pop();
}

if (this.connections.length &lt; this.poolSize) {
const client = new ErlVectorDBClient(this.options);
await client.connect();
await client.initialize();
this.connections.push(client);
return client;
}

// Wait for available connection
return new Promise(resolve =&gt; {
const checkAvailable = () =&gt; {
if (this.available.length &gt; 0) {
resolve(this.available.pop());
} else {
setTimeout(checkAvailable, 10);
}
};
checkAvailable();
});
}

releaseConnection(client) {
this.available.push(client);
}
}

错误处理和重试逻辑```javascript

class RobustErlVectorDBClient extends ErlVectorDBClient {
async sendRequestWithRetry(method, params, maxRetries = 3) {
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
return await this.sendRequest(method, params);
} catch (error) {
if (attempt === maxRetries) throw error;

// Handle specific error types
if (error.message.includes('token_expired')) {
await this.getAccessToken();
} else if (error.message.includes('connection')) {
await this.connect();
await this.initialize();
}

// Exponential backoff
await new Promise(resolve =>
setTimeout(resolve, Math.pow(2, attempt) * 1000)
);
}
}
}
}


### MCP故障排除

#### 常见问题

**1.身份验证错误**```
Error: Authentication required
  • 验证OAuth服务器是否在端口8081上运行
  • 检查客户端凭据是否正确
  • 确保令牌未过期(默认值:1小时)

2.连接被拒绝```
Error: ECONNREFUSED


- 验证ErlVectorDB是否正在运行
- 检查MCP端口配置(默认值:8080)
- 确保防火墙允许连接

**3.无效的工具调用**```
Error: Insufficient permissions
  • 检查OAuth作用域是否符合工具要求
  • 验证客户端是否具有必要的权限
  • 审查基于范围的访问控制

4.JSON解析错误```
Error: Unexpected token in JSON


- 确保JSON格式正确
- 检查尾随逗号或语法错误
- 验证UTF-8编码

#### 调试模式

在ErlVectorDB中启用调试日志记录:```erlang
% In config/sys.config
{kernel, [
{logger_level, debug},
{logger, [
{handler, default, logger_std_h,
#{config =&gt; #{type =&gt; standard_io},
formatter =&gt; {logger_formatter, #{}}}}
]}
]}

健康检查端点

测试服务器运行状况:```bash

Check if servers are responding

curl -f http://localhost:8081/oauth/client_info \
-H "Authorization: Bearer YOUR_TOKEN" || echo "OAuth server down"

telnet localhost 8080 || echo "MCP server down"


### MCP性能优化

#### 批量操作```javascript
// Batch insert multiple vectors
async function batchInsert(client, store, vectors) {
const promises = vectors.map(({id, vector, metadata}) =&gt;
client.insertVector(store, id, vector, metadata)
);
return Promise.all(promises);
}

连接保持活跃```javascript

// Implement heartbeat to keep connection alive
setInterval(() => {
if (client.socket && !client.socket.destroyed) {
client.listTools().catch(err => {
console.log('Heartbeat failed, reconnecting...');
client.connect();
});
}
}, 30000); // 30 seconds


#### 大向量压缩```javascript
// Use compression for large vectors
async function insertLargeVector(client, store, id, vector, metadata) {
if (vector.length &gt; 1000) {
// Let server handle compression
return client.callTool(&#x27;insert_compressed_vector&#x27;, {
store, id, vector, metadata
});
} else {
return client.insertVector(store, id, vector, metadata);
}
}

配置

编辑 config/sys.config:```erlang
[
{erlvectordb, [
% Network configuration
{mcp_port, 8080},
{oauth_port, 8081},
{rest_api_port, 8082},
{rest_api_enabled, true},

% Authentication
{oauth_enabled, true},
{create_default_client, true},
{default_client_id, <<"admin">>},
{default_client_secret, <<"admin_secret_2024">>},
{token_lifetime, 3600000}, % 1 hour
{refresh_token_lifetime, 86400000}, % 24 hours

% Clustering
{cluster_enabled, false},
{node_name, 'erlvectordb@localhost'},
{cluster_cookie, erlvectordb_cluster},
{replication_factor, 2},
{heartbeat_interval, 5000},

% Compression
{compression_enabled, true},
{compression_algorithm, quantization_8bit},

% Storage
{persistence_enabled, true},
{persistence_dir, "data"},
{backup_dir, "backups"},

…(正文过长,页面只展示前面部分,完整内容见仓库)
```

常见问题

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

在客户端按下面的安装命令接入:pip install google-generativeai。装完在客户端配置里引用同一个包或端点。

Erlvectordb (Modzer0) 怎么在 Claude Desktop、Claude 里配置?

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

Erlvectordb (Modzer0) 收费吗?

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

Erlvectordb (Modzer0) 需要 API Key 吗?

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

Erlvectordb (Modzer0) 支持哪些客户端?

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

Erlvectordb (Modzer0) 能提供哪些能力?

资料显示约 8 个工具;能力标签包括 分布式系统、HTML、Claude、向量数据库。具体工具清单以官方文档为准。

Erlvectordb (Modzer0) 需要什么运行环境?

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

Erlvectordb (Modzer0) 是本地还是远程?

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

热门专题

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

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