ASR Graph of Thoughts (GoT) Model Context Protocol (MCP) Server
About
The Advanced Scientific Research (ASR) Graph of Thoughts (GoT) MCP server is a highly efficient implementation of the Model Context Protocol (MCP) that allows for sophisticated reasoning workflows using graph-based representations.
Details
- Author
- SaptaDey
- GitHub stars
- 12
- Downloads
- 193
- Categories
- Other
Jump to
- Graph of Thoughts reasoning approach
- Eight processing stages from initialization to reflection
- Docker Compose multi-container deployment
- FastAPI backend exposed on port 8082
- Static client served via nginx on port 80
- MCP-compatible with Claude and API integrations
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
ASR Graph of Thoughts (GoT) Model Context Protocol (MCP) ServerCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
Run the server using Docker with docker compose up --build. Alternatively, clone the repository, create a Python virtual environment, install dependencies with pip install -r requirements.txt, and start the server with python src/server.py.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"asr graph of thoughts (got) model context protocol (mcp) server": {
"Graph-of-Thought-MCP": {
"command": "docker",
"args": [
"compose",
"up",
"--build"
]
}
}
}
}McpServers
{
"Graph-of-Thought-MCP": {
"command": "docker",
"args": [
"compose",
"up",
"--build"
]
}
}ASR Graph of Thoughts (GoT) Model Context Protocol (MCP) Server
The Advanced Scientific Research (ASR) Graph of Thoughts (GoT) MCP server is a highly efficient implementation of the Model Context Protocol (MCP) that allows for sophisticated reasoning workflows using graph-based representations.
Project Overview
This project implements a Model Context Protocol (MCP) server architecture that leverages a Graph of Thoughts approach to enhance AI reasoning capabilities. It can be connected to AI models or applications like Claude desktop app or API-based integrations.
Project Structure
asr-got-mcp/
├── docker-compose.yml # Docker Compose configuration for multi-container setup
├── Dockerfile # Docker configuration for the backend
├── requirements.txt # Python dependencies
├── src/ # Source code
│ ├── server.py # Main server implementation
│ ├── asr_got/ # Core ASR-GoT implementation
│ │ ├── core.py # Core functionality
│ │ ├── stages/ # Processing stages
│ │ │ ├── stage_1_initialization.py
│ │ │ ├── stage_2_decomposition.py
│ │ │ ├── stage_3_hypothesis.py
│ │ │ ├── stage_4_evidence.py
│ │ │ ├── stage_5_pruning.py
│ │ │ ├── stage_6_subgraph.py
│ │ │ ├── stage_7_composition.py
│ │ │ └── stage_8_reflection.py
│ │ ├── utils/ # Utility functions
│ │ └── models/ # Data models
│ └── api/ # API implementation
│ ├── routes.py # API routes
│ └── schema.py # API schemas
├── config/ # Configuration files
└── tests/ # Test suite
Running the Project with Docker
This project provides a multi-container Docker setup for both the Python backend (FastAPI) and the static JavaScript client. The setup uses Docker Compose for orchestration.
Project-Specific Docker Requirements
- Python Version: 3.13-slim (as specified in the backend Dockerfile) - System Dependencies:build-essential, curl (installed in the backend image)
- Non-root Users: Both backend and client containers run as non-root users for security
- Virtual Environment: Python dependencies are installed in a virtual environment (/app/.venv)
- Static Client: Served via nginx (alpine) in a separate container
Environment Variables
The backend service sets the following environment variables (see Dockerfile): -PYTHONUNBUFFERED=1
- MCP_SERVER_PORT=8082 (the FastAPI server port)
- LOG_LEVEL=INFO
> Note: If you need to override or add environment variables, you can uncomment and use the env_file option in docker-compose.yml.
Exposed Ports
- Backend (python-app): - Host:8082 → Container: 8082 (FastAPI server)
- Client (js-client):
- Host: 80 → Container: 80 (nginx static server)
Build and Run Instructions
1. Build and start all services: docker compose up --build
2. Access the services:
- Backend API: http://localhost:8082
- Static Client: http://localhost/
Integration with AI Models
This MCP server can be integrated with:
- Claude desktop application
- API-based integrations with AI models
- Other MCP-compatible clients
Development
To set up a development environment without Docker:
1. Clone this repository
2. Create a virtual environment: python -m venv venv
3. Activate the virtual environment:
- Windows: venv\Scripts\activate
- Linux/Mac: source venv/bin/activate
4. Install dependencies: pip install -r requirements.txt
5. Run the server: python src/server.py
License
This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
---
_If you update dependencies, remember to rebuild the images with docker compose build._
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
