Skip to main content
Glama
deenesjakoruzh
sosacrazy126

greptile-mcp

by sosacrazy126
OverviewSchemaRelated ServersScoreDiscussions
Python
Hybrid

Greptile MCP 服务器 [已完成]

快速运行命令备忘单

✅ 项目状态：所有任务已完成（11/11）

请参阅PROJECT_COMPLETION.md了解已完成工作的摘要，并参阅USER_GUIDE.md了解使用说明。

环境

设置和安装

运行命令

本地（Python）

python -m venv .venv && source .venv/bin/activate && pip install -e .

python -m src.main

Docker

docker build -t greptile-mcp .

docker run --rm --env-file .env -p 8050:8050 greptile-mcp

锻造工艺

npm install -g smithery

smithery deploy （参见 smithery.yaml）

使用.env.example填写.env并在运行之前设置您的GREPTILE_API_KEY和GITHUB_TOKEN 。

有关完整的先决条件、高级代理使用、集成和故障排除：请参阅

MCP（模型上下文协议）服务器实现与 Greptile API 集成，为 AI 代理提供代码搜索和查询功能。

铁匠徽章

特征

该服务器提供了四个基本的 Greptile 工具，使 AI 代理能够与代码库进行交互：

  1. index_repository ：索引存储库以进行代码搜索和查询。

    • 处理存储库以使其可搜索

    • 当存储库更改时更新现有索引

    • 配置通知首选项

  2. query_repository ：查询存储库以获取带有代码参考的答案。

    • 询问有关代码库的自然语言问题

    • 获取引用特定代码位置的详细答案

    • 支持使用会话 ID 的对话历史记录

  3. search_repository ：在存储库中搜索相关文件，但不生成完整答案。

    • 查找与特定概念或功能相关的文件

    • 获取按相关性排序的上下文匹配

    • 当仅需要文件位置时，比完整查询更快

  4. get_repository_info ：获取有关索引存储库的信息。

    • 检查索引状态和进度

    • 验证哪些存储库可供查询

    • 获取有关索引存储库的元数据

Related MCP server: Graphiti MCP Server

Smithery部署

Greptile MCP 服务器支持通过 Smithery 进行部署。项目根目录中包含一个smithery.yaml配置文件。

Smithery 配置

Smithery 配置在smithery.yaml中定义，并支持以下选项：

build:
  dockerfile: Dockerfile

startCommand:
  type: stdio
  configSchema:
    type: object
    required:
      - greptileApiKey
      - githubToken
    properties:
      greptileApiKey:
        type: string
        description: "API key for accessing the Greptile API"
      githubToken:
        type: string
        description: "GitHub Personal Access Token for repository access"
      baseUrl:
        type: string
        description: "Base URL for Greptile API"
        default: "https://api.greptile.com/v2"
      host:
        type: string
        description: "Host to bind to when using SSE transport"
        default: "0.0.0.0"
      port:
        type: string
        description: "Port to listen on when using SSE transport"
        default: "8050"

与 Smithery 一起使用

要使用 Smithery 进行部署：

  1. 安装 Smithery： npm install -g smithery

  2. 部署服务器： smithery deploy

  3. 使用所需的 API 密钥配置您的 Smithery 客户端

其他文档

有关AI代理的详细使用说明，请参阅代理使用指南。

先决条件

  • Python 3.12+

  • Greptile API 密钥（来自https://app.greptile.com/settings/api ）

  • **GitHub 或 GitLab 个人访问令牌 (PAT)，**具有您要索引的存储库的repo (或等效读取) 权限

  • Docker （推荐部署）

所需的 Python 包

  • fastmcp ——MCP 服务器实现

  • httpx - 异步 HTTP 客户端

  • python-dotenv - 环境变量管理

  • uvicorn - 用于 SSE 传输的 ASGI 服务器

安装

使用 pip（用于开发或本地测试）

  1. 克隆此存储库：

    git clone https://github.com/sosacrazy126/greptile-mcp.git
cd greptile-mcp

  2. 创建虚拟环境（推荐）：

    python -m venv .venv
source .venv/bin/activate  # On Windows use `.venv\Scripts\activate`

  3. 安装依赖项：

    pip install -e .

  4. 根据.env.example创建.env文件：

    cp .env.example .env

  5. 在.env文件中配置环境变量：

    GREPTILE_API_KEY=your_api_key_here
GITHUB_TOKEN=your_github_token_here

使用 Docker（推荐部署）

  1. 克隆存储库：

    git clone https://github.com/sosacrazy126/greptile-mcp.git
cd greptile-mcp

  2. 根据.env.example创建一个.env文件并配置您的环境变量。

  3. 构建 Docker 镜像：

    docker build -t greptile-mcp .

运行服务器

使用 pip

SSE 传输（默认）

确保在.env文件中设置了TRANSPORT=sse和PORT=8050 （或您选择的端口）。

python -m src.main

服务器将监听http://<HOST>:<PORT>/sse 。

标准传输

在.env文件中设置TRANSPORT=stdio 。使用 stdio 时，MCP 客户端通常会启动 MCP 服务器进程。

# Usually invoked by an MCP client, not directly
TRANSPORT=stdio python -m src.main

使用 Docker

SSE 传输（默认）

# Mounts the .env file for configuration and maps the port
docker run --rm --env-file .env -p 8050:8050 greptile-mcp

服务器将监听http://localhost:8050/sse （如果不是 localhost，则为主机 IP）。

标准传输

配置您的 MCP 客户端以使用TRANSPORT=stdio运行 Docker 容器。

# Example of running with stdio transport
docker run --rm -i --env-file .env -e TRANSPORT=stdio greptile-mcp

与 MCP 客户端集成

SSE配置示例

将其添加到您的 MCP 客户端的配置中（例如mcp_config.json ）：

{
  "mcpServers": {
    "greptile": {
      "transport": "sse",
      "url": "http://localhost:8050/sse"
    }
  }
}

Python 与 Stdio 配置示例

确保在运行命令的环境中设置了TRANSPORT=stdio ：

{
  "mcpServers": {
    "greptile": {
      "transport": "stdio",
      "command": "/path/to/your/greptile-mcp/.venv/bin/python",
      "args": ["-m", "src.main"],
      "env": {
        "TRANSPORT": "stdio",
        "GREPTILE_API_KEY": "YOUR-GREPTILE-API-KEY",
        "GITHUB_TOKEN": "YOUR-GITHUB-TOKEN",
        "GREPTILE_BASE_URL": "https://api.greptile.com/v2"
      }
    }
  }
}

Docker 与 Stdio 配置示例

{
  "mcpServers": {
    "greptile": {
      "transport": "stdio",
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-e", "TRANSPORT=stdio",
        "-e", "GREPTILE_API_KEY",
        "-e", "GITHUB_TOKEN",
        "-e", "GREPTILE_BASE_URL",
        "greptile-mcp"
      ],
      "env": {
        "GREPTILE_API_KEY": "YOUR-GREPTILE-API-KEY",
        "GITHUB_TOKEN": "YOUR-GITHUB-TOKEN",
        "GREPTILE_BASE_URL": "https://api.greptile.com/v2"
      }
    }
  }
}

详细使用指南

代码库分析工作流程

  1. 您想要使用index_repository分析的索引存储库

  2. 使用get_repository_info验证索引状态以确保处理完成

  3. 使用query_repository使用自然语言查询存储库

  4. 使用search_repository查找与功能或概念相关的特定文件

对话上下文的会话管理

当通过任何客户端（包括 Smithery）与 Greptile MCP 服务器交互时，适当的会话管理对于维护对话上下文至关重要：

  1. 在对话开始时生成唯一的会话 ID

  2. 对所有相关的后续查询重复使用相同的会话 ID

  3. 开始新对话时创建新的会话 ID

会话 ID 管理示例：

# Generate a unique session ID
import uuid
session_id = str(uuid.uuid4())

# Initial query
initial_response = query_repository(
    query="How is authentication implemented?",
    repositories=[{"remote": "github", "repository": "owner/repo", "branch": "main"}],
    session_id=session_id  # Include the session ID
)

# Follow-up query using the SAME session ID
followup_response = query_repository(
    query="Can you provide more details about the JWT verification?",
    repositories=[{"remote": "github", "repository": "owner/repo", "branch": "main"}],
    session_id=session_id  # Reuse the same session ID
)

Smithery 集成重要提示：通过 Smithery 连接的代理必须生成并维护自己的会话 ID。Greptile MCP 服务器不会自动生成会话 ID。会话 ID 应包含在代理的对话状态中。

最佳实践

  • 索引性能：较小的存储库索引速度更快。对于大型的单一存储库，请考虑索引特定的分支或标签。

  • 查询优化：查询时务必具体。包含相关的技术术语，以获得更好的结果。

  • 存储库选择：查询多个存储库时，按相关性顺序列出它们以获得最佳结果。

  • 会话管理：使用会话 ID 来跟踪后续问题，以维护查询的上下文。

API 参考

1. 索引库

对存储库进行索引，以便在将来的查询中可以搜索它。

参数：

  • remote （字符串）：存储库主机，可以是“github”或“gitlab”

  • repository （字符串）：所有者/repo 格式的存储库（例如“greptileai/greptile”）

  • branch （字符串）：要索引的分支（例如“main”）

  • reload （布尔值，可选）：是否强制重新处理先前索引的存储库

  • notify （布尔值，可选）：索引完成时是否发送电子邮件通知

例子：

// Tool Call: index_repository
{
  "remote": "github",
  "repository": "greptileai/greptile",
  "branch": "main",
  "reload": false,
  "notify": false
}

回复：

{
  "message": "Indexing Job Submitted for: greptileai/greptile",
  "statusEndpoint": "https://api.greptile.com/v2/repositories/github:main:greptileai%2Fgreptile"
}

2. 查询存储库

使用自然语言查询存储库以获取带有代码参考的答案。

参数：

  • query （字符串）：关于代码库的自然语言查询

  • repositories （数组）：要查询的存储库列表，每个存储库的格式如下：

    {
  "remote": "github",
  "repository": "owner/repo",
  "branch": "main"
}

  • session_id （字符串，可选）：用于继续对话的会话 ID

  • stream （布尔值，可选）：是否流式传输响应

  • genius （布尔值，可选）：是否使用增强查询功能

例子：

// Tool Call: query_repository
{
  "query": "How is authentication handled in this codebase?",
  "repositories": [
    {
      "remote": "github",
      "repository": "greptileai/greptile",
      "branch": "main"
    }
  ],
  "session_id": null,
  "stream": false,
  "genius": true
}

回复：

{
  "message": "Authentication in this codebase is handled using JWT tokens...",
  "sources": [
    {
      "repository": "greptileai/greptile",
      "remote": "github",
      "branch": "main",
      "filepath": "/src/auth/jwt.js",
      "linestart": 14,
      "lineend": 35,
      "summary": "JWT token validation middleware"
    }
  ]
}

3. 搜索存储库

搜索存储库以查找相关文件但不生成完整答案。

参数：

  • query （字符串）：关于代码库的搜索查询

  • repositories （数组）：要搜索的存储库列表

  • session_id （字符串，可选）：用于继续对话的会话 ID

  • genius （布尔值，可选）：是否使用增强搜索功能

例子：

// Tool Call: search_repository
{
  "query": "Find files related to authentication middleware",
  "repositories": [
    {
      "remote": "github",
      "repository": "greptileai/greptile", 
      "branch": "main"
    }
  ],
  "session_id": null,
  "genius": true
}

回复：

{
  "sources": [
    {
      "repository": "greptileai/greptile",
      "remote": "github",
      "branch": "main",
      "filepath": "/src/auth/middleware.js",
      "linestart": 1,
      "lineend": 45,
      "summary": "Authentication middleware implementation"
    },
    {
      "repository": "greptileai/greptile",
      "remote": "github",
      "branch": "main",
      "filepath": "/src/auth/jwt.js",
      "linestart": 1,
      "lineend": 78,
      "summary": "JWT token handling functions"
    }
  ]
}

4. 获取存储库信息

获取有关已索引的特定存储库的信息。

参数：

  • remote （字符串）：存储库主机，可以是“github”或“gitlab”

  • repository （字符串）：所有者/repo 格式的存储库

  • branch （字符串）：被索引的分支

例子：

// Tool Call: get_repository_info
{
  "remote": "github",
  "repository": "greptileai/greptile",
  "branch": "main"
}

回复：

{
  "repository": "greptileai/greptile",
  "remote": "github",
  "branch": "main",
  "private": false,
  "status": "COMPLETED",
  "filesProcessed": 234,
  "numFiles": 234,
  "sha": "a1b2c3d4e5f6..."
}

集成示例

1. 通过 Anthropic API 与 Claude.ai 集成

from anthropic import Anthropic
import json
import requests

# Set up Anthropic client
anthropic = Anthropic(api_key="your_anthropic_key")

# Function to call Greptile MCP
def query_code(question, repositories):
    response = requests.post(
        "http://localhost:8050/tools/greptile/query_repository",
        json={
            "query": question,
            "repositories": repositories,
            "genius": True
        }
    )
    return json.loads(response.text)

# Ask Claude with enhanced code context
def ask_claude_with_code_context(question, repositories):
    # Get code context from Greptile
    code_context = query_code(question, repositories)
    
    # Format the context for Claude
    formatted_context = f"Code Analysis Result:\n{code_context['message']}\n\nRelevant Files:\n"
    for source in code_context.get('sources', []):
        formatted_context += f"- {source['filepath']} (lines {source['linestart']}-{source['lineend']})\n"
    
    # Send to Claude with context
    message = anthropic.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=1000,
        messages=[
            {"role": "user", "content": f"Based on this code context:\n\n{formatted_context}\n\nQuestion: {question}"}
        ]
    )
    
    return message.content

# Example usage
answer = ask_claude_with_code_context(
    "How does the authentication system work?",
    [{"remote": "github", "repository": "greptileai/greptile", "branch": "main"}]
)
print(answer)

2. 与基于 LLM 的聊天机器人集成

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import httpx
import json

app = FastAPI()

# Greptile MCP endpoint
GREPTILE_MCP_URL = "http://localhost:8050/tools/greptile"

@app.post("/chat")
async def chat_endpoint(request: Request):
    data = await request.json()
    user_message = data.get("message", "")
    
    # Check if this is a code-related question
    if "code" in user_message or "repository" in user_message or "function" in user_message:
        # Query the repository through Greptile MCP
        async with httpx.AsyncClient() as client:
            response = await client.post(
                f"{GREPTILE_MCP_URL}/query_repository",
                json={
                    "query": user_message,
                    "repositories": [
                        {"remote": "github", "repository": "your-org/your-repo", "branch": "main"}
                    ],
                    "genius": True
                }
            )
            
            greptile_result = response.json()
            
            # Process the result and return to the user
            answer = greptile_result.get("message", "")
            sources = greptile_result.get("sources", [])
            
            return JSONResponse({
                "message": answer,
                "code_references": sources
            })
    
    # For non-code questions, use your regular LLM
    return JSONResponse({
        "message": "This appears to be a general question. I'll handle it normally."
    })

# Run with: uvicorn app:app --reload

3. 命令行代码查询工具

#!/usr/bin/env python3
import argparse
import json
import requests
import sys

def main():
    parser = argparse.ArgumentParser(description="Query code repositories using natural language")
    parser.add_argument("query", help="The natural language query about the code")
    parser.add_argument("--repo", "-r", required=True, help="Repository in format github:owner/repo:branch")
    parser.add_argument("--genius", "-g", action="store_true", help="Use enhanced query capabilities")
    args = parser.parse_args()
    
    # Parse the repository string
    try:
        remote, repo_path = args.repo.split(":", 1)
        if ":" in repo_path:
            repo, branch = repo_path.split(":", 1)
        else:
            repo = repo_path
            branch = "main"
    except ValueError:
        print("Error: Repository must be in format 'github:owner/repo:branch' or 'github:owner/repo'")
        sys.exit(1)
        
    # Prepare the request
    payload = {
        "query": args.query,
        "repositories": [
            {
                "remote": remote,
                "repository": repo,
                "branch": branch
            }
        ],
        "genius": args.genius
    }
    
    # Make the request
    try:
        response = requests.post(
            "http://localhost:8050/tools/greptile/query_repository",
            json=payload
        )
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        sys.exit(1)
    
    # Process the response
    result = response.json()
    
    # Display the answer
    print("\n=== ANSWER ===\n")
    print(result.get("message", "No answer found"))
    
    # Display the sources
    sources = result.get("sources", [])
    if sources:
        print("\n=== CODE REFERENCES ===\n")
        for i, source in enumerate(sources, 1):
            print(f"{i}. {source['filepath']} (lines {source.get('linestart', '?')}-{source.get('lineend', '?')})")
            print(f"   Repository: {source['repository']} ({source['branch']})")
            if 'summary' in source:
                print(f"   Summary: {source['summary']}")
            print()

if __name__ == "__main__":
    main()

故障排除

常见问题

1. 身份验证失败

症状：您收到401 Unauthorized或未Repository not found with configured credentials错误。

解决方案：

  • 验证您的 Greptile API 密钥是否有效并在.env文件中正确设置

  • 检查你的 GitHub/GitLab 令牌是否已过期（它们通常会在一段设定的时间后过期）

  • 确保您的 GitHub/GitLab 令牌具有访问存储库的repo范围

  • 直接使用 GitHub API 测试您的 GitHub 令牌以验证其是否正常工作

测试 GitHub 令牌：

curl -H "Authorization: token YOUR_GITHUB_TOKEN" https://api.github.com/user

2. 未找到存储库

症状：API 返回 404 错误或“未找到存储库”消息。

解决方案：

  • 验证存储库是否存在并且可以使用 GitHub/GitLab 令牌进行访问

  • 仔细检查存储库格式（应该是owner/repo ）

  • 对于私有存储库，请确保您的令牌具有适当的访问权限

  • 验证分支名称是否正确

3.连接问题

症状：无法连接到 MCP 服务器。

解决方案：

  • 检查服务器是否正在运行（ ps aux | grep src.main ）

  • 验证端口未被其他应用程序使用

  • 检查网络设置和防火墙配置

  • 通过更改.env文件中的PORT值尝试不同的端口

4. Docker问题

症状：Docker 容器无法启动或运行正常。

解决方案：

  • 检查 Docker 日志： docker logs <container_id>

  • 验证.env文件是否已正确挂载

  • 确保docker run命令中的端口映射正确

  • 检查 Docker 网络配置是否允许所需的连接

日志和调试

要启用更详细的日志记录，请设置以下环境变量：

# Add to your .env file
DEBUG=true
LOG_LEVEL=debug

要对特定的 MCP 交互进行故障排除，请检查 MCP 服务器日志：

# Run with enhanced logging
LOG_LEVEL=debug python -m src.main

高级配置

环境变量

多变的

描述

默认

TRANSPORT

传输方法（ sse或stdio ）

sse

HOST

绑定到 SSE 传输的主机

0.0.0.0

PORT

SSE运输港口

8050

GREPTILE_API_KEY

您的 Greptile API 密钥

（必需的）

GITHUB_TOKEN

GitHub/GitLab 个人访问令牌

（必需的）

GREPTILE_BASE_URL

Greptile API 基本 URL

https://api.greptile.com/v2

DEBUG

启用调试模式

false

LOG_LEVEL

日志级别

info

自定义 API 端点

如果您需要使用自定义 Greptile API 端点（例如，用于企业安装），请修改GREPTILE_BASE_URL环境变量：

GREPTILE_BASE_URL=https://greptile.your-company.com/api/v2

性能调优

对于生产部署，请考虑以下性能优化：

  1. 工作者配置：当使用 Uvicorn 的 SSE 传输时，配置适当的工作者数量：

    # For CPU-bound applications: workers = 1-2 × CPU cores
uvicorn src.main:app --workers 4

  2. 超时设置：调整大型存储库的超时：

    # Add to .env
GREPTILE_TIMEOUT=120.0  # Default is 60.0 seconds

  3. 内存优化：对于大型部署，请考虑容器资源限制：

    docker run --rm --env-file .env -p 8050:8050 --memory="1g" --cpus="1.0" greptile-mcp

贡献

欢迎贡献代码！欢迎提交 Pull 请求。

  1. 分叉存储库

  2. 创建你的功能分支（ git checkout -b feature/amazing-feature ）

  3. 提交您的更改（ git commit -m 'Add some amazing feature' ）

  4. 推送到分支（ git push origin feature/amazing-feature ）

  5. 打开拉取请求

开发设置

为了开发，请安装其他依赖项：

pip install -e ".[dev]"

运行测试：

pytest

执照

该项目根据 MIT 许可证获得许可 - 有关详细信息，请参阅 LICENSE 文件。

由（ https://github.com/sosacrazy126 ）构建

Install Server
A
security – no known vulnerabilities
A
license - permissive license
A
quality - confirmed to work

How are these scores calculated?

Resources

Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/sosacrazy126/greptile-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server