# ASR Graph of Thoughts (GoT) Model Context Protocol (MCP) Server

[![Version](https://img.shields.io/badge/version-0.1.0-blue.svg)](https://saptadey.github.io/Adaptive-Graph-of-Thoughts-MCP-server/)
[![Python](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
[![License](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
[![Docker](https://img.shields.io/badge/docker-ready-brightgreen.svg)](Dockerfile)
[![FastAPI](https://img.shields.io/badge/FastAPI-0.111.1-009688.svg)](https://fastapi.tiangolo.com)
[![NetworkX](https://img.shields.io/badge/NetworkX-3.3-orange.svg)](https://networkx.org)
[![Last Updated](https://img.shields.io/badge/last_updated-Jun_2025-lightgrey.svg)](CHANGELOG.md)
[![smithery badge](https://smithery.ai/badge/@SaptaDey/graph-of-thought-mcp)](https://smithery.ai/server/@SaptaDey/graph-of-thought-mcp)
[![Codacy Security Scan](https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server/actions/workflows/codacy.yml/badge.svg)](https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server/actions/workflows/codacy.yml)
[![CodeQL Advanced](https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server/actions/workflows/codeql.yml/badge.svg)](https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server/actions/workflows/codeql.yml)
[![Dependabot Updates](https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server/actions/workflows/dependabot/dependabot-updates/badge.svg)](https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server/actions/workflows/dependabot/dependabot-updates)
[![Verified on MseeP](https://mseep.ai/badge.svg)](https://mseep.ai/app/b56538c9-7a30-45b3-851c-447fe2eb24a6)

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:**
   ```sh
   docker compose up --build
   ```
   This will build both the backend and client images and start the containers.

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`._