에이전트 강화
게시자가 제공하는 설치 방식입니다. PlugMCP 엔드포인트가 아닙니다.
원격 URL인가요, 내 컴퓨터에서 실행하는 명령인가요? 두 설치 방식의 차이
PlugMCP에서 실행
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
실행🚀 Next-Generation AI Reasoning Framework for Scientific Research
Leveraging graph structures to transform how AI systems approach scientific reasoning
Adaptive Graph of Thoughts (AGoT) is a high-performance MCP server that implements the Advanced Scientific Reasoning Graph-of-Thoughts (ASR-GoT) framework. It uses a Neo4j graph database as a dynamic knowledge store and exposes reasoning capabilities through the Model Context Protocol (MCP), enabling seamless integration with AI assistants like Claude Desktop.
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#4A90D9', 'primaryTextColor': '#fff', 'primaryBorderColor': '#2C5F8A', 'lineColor': '#666', 'secondaryColor': '#52B788', 'tertiaryColor': '#F8F9FA'}}}%%
graph TB
subgraph Clients["🖥️ Client Layer"]
CD["🤖 Claude Desktop"]
VS["💻 VS Code / Cursor"]
CC["🔗 Custom MCP Clients"]
end
subgraph Gateway["🌐 API Gateway Layer"]
MCP_EP["⚡ MCP Endpoint\n/mcp"]
NLQ_EP["🔍 NLQ Endpoint\n/nlq"]
GE_EP["📊 Graph Explorer\n/graph"]
HE["💚 Health Check\n/health"]
end
subgraph Core["🧠 Core Application Layer"]
direction TB
GTP["🔄 GoT Processor\nOrchestrator"]
subgraph Pipeline["ASR-GoT 8-Stage Pipeline"]
S1["1️⃣ Init &\nContext Setup"]
S2["2️⃣ Query\nDecomposition"]
S3["3️⃣ Hypothesis\nGeneration"]
S4["4️⃣ Evidence\nIntegration"]
S5["5️⃣ Pruning &\nMerging"]
S6["6️⃣ Subgraph\nExtraction"]
S7["7️⃣ Synthesis &\nComposition"]
S8["8️⃣ Reflection &\nAudit"]
S1 --> S2 --> S3 --> S4 --> S5 --> S6 --> S7 --> S8
end
GTP --> Pipeline
end
subgraph Services["🛠️ Service Layer"]
LLM["🤖 LLM Service\nOpenAI / Claude"]
EDB["📚 Evidence DB\nPubMed · Scholar · Exa"]
end
subgraph Storage["🗄️ Storage Layer"]
NEO4J["📦 Neo4j\nGraph Database"]
CONFIG["⚙️ Config\n(YAML + ENV)"]
end
Clients -->|"MCP JSON-RPC\nBearer Auth"| Gateway
MCP_EP --> GTP
NLQ_EP --> LLM
GE_EP --> NEO4J
GTP --> Services
GTP --> NEO4J
LLM --> EDB
style Clients fill:#E3F2FD,stroke:#1565C0
style Gateway fill:#F3E5F5,stroke:#6A1B9A
style Core fill:#E8F5E9,stroke:#1B5E20
style Services fill:#FFF8E1,stroke:#F57F17
style Storage fill:#FCE4EC,stroke:#880E4F
The 8-stage reasoning pipeline transforms a raw question into a comprehensive, evidence-backed answer stored in the knowledge graph:
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#7B68EE', 'edgeLabelBackground': '#fff'}}}%%
flowchart LR
Q([❓ Scientific\nQuestion]) --> S1
subgraph S1["Stage 1: Initialization"]
I1["Set context\n& parameters"]
I2["Create root\ngraph node"]
I1 --> I2
end
subgraph S2["Stage 2: Decomposition"]
D1["Identify\nsub-questions"]
D2["Map knowledge\ndomains"]
D1 --> D2
end
subgraph S3["Stage 3: Hypothesis"]
H1["Generate\nhypotheses"]
H2["Score initial\nconfidence"]
H1 --> H2
end
subgraph S4["Stage 4: Evidence"]
E1["Query PubMed\nScholar · Exa"]
E2["Integrate\nevidence nodes"]
E1 --> E2
end
subgraph S5["Stage 5: Pruning"]
P1["Remove weak\nhypotheses"]
P2["Merge related\nnodes"]
P1 --> P2
end
subgraph S6["Stage 6: Subgraph"]
SG1["Extract key\nsubgraphs"]
SG2["Score relevance\n& centrality"]
SG1 --> SG2
end
subgraph S7["Stage 7: Synthesis"]
C1["Compose final\nnarrative"]
C2["Build\nconclusions"]
C1 --> C2
end
subgraph S8["Stage 8: Reflection"]
R1["Audit\nconsistency"]
R2["Return final\nresult"]
R1 --> R2
end
S1 --> S2 --> S3 --> S4 --> S5 --> S6 --> S7 --> S8
S8 --> A([✅ Reasoned\nAnswer])
style Q fill:#FFD700,stroke:#DAA520,color:#000
style A fill:#90EE90,stroke:#228B22,color:#000
The Neo4j knowledge graph captures the reasoning structure as a rich connectome — nodes represent concepts, hypotheses, and evidence, while edges represent semantic and logical relationships:
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#6C63FF', 'primaryTextColor': '#fff', 'edgeLabelBackground': '#f0f0ff'}}}%%
graph TD
RootQuery["🔍 Root Query\n(Session Node)"]
subgraph Decomp["📐 Decomposition Layer"]
D1["📌 Sub-question A\n[domain: biology]"]
D2["📌 Sub-question B\n[domain: chemistry]"]
D3["📌 Sub-question C\n[domain: physics]"]
end
subgraph Hypo["💡 Hypothesis Layer"]
H1["💭 Hypothesis 1\nconf: 0.85"]
H2["💭 Hypothesis 2\nconf: 0.72"]
H3["💭 Hypothesis 3\nconf: 0.61"]
H4["💭 Hypothesis 4\nconf: 0.90"]
end
subgraph Evid["🔬 Evidence Layer"]
E1["📄 PubMed Paper\nPMID: 38492"]
E2["📄 Scholar Article\nDOI: 10.1038/..."]
E3["🌐 Exa Result\nexpert consensus"]
E4["📊 Statistical\nMeta-analysis"]
end
subgraph Synth["🎯 Synthesis Layer"]
C1["✅ Merged\nConclusion A"]
C2["✅ Merged\nConclusion B"]
FINAL["🏆 Final Answer\n[confidence: 0.88]"]
end
RootQuery -->|"DECOMPOSES_TO"| D1
RootQuery -->|"DECOMPOSES_TO"| D2
RootQuery -->|"DECOMPOSES_TO"| D3
D1 -->|"GENERATES"| H1
D1 -->|"GENERATES"| H2
D2 -->|"GENERATES"| H3
D3 -->|"GENERATES"| H4
H1 -->|"SUPPORTED_BY"| E1
H2 -->|"SUPPORTED_BY"| E2
H3 -->|"CONTRADICTED_BY"| E3
H4 -->|"SUPPORTED_BY"| E4
H1 -->|"MERGES_WITH"| C1
H4 -->|"MERGES_WITH"| C1
H2 -->|"MERGES_WITH"| C2
C1 -->|"SYNTHESIZES_TO"| FINAL
C2 -->|"SYNTHESIZES_TO"| FINAL
style RootQuery fill:#4A90D9,color:#fff,stroke:#2C5F8A
style FINAL fill:#27AE60,color:#fff,stroke:#1E8449
style H3 fill:#E74C3C,color:#fff,stroke:#C0392B
%%{init: {'theme': 'base'}}%%
sequenceDiagram
actor User as 🤖 Claude / MCP Client
participant API as ⚡ FastAPI Server
participant Auth as 🔐 Auth Middleware
participant GTP as 🧠 GoT Processor
participant NEO as 📦 Neo4j DB
participant LLM as 🤖 LLM Service
User->>API: POST /mcp {"method": "asr_got.query"}
API->>Auth: Verify Bearer Token
Auth-->>API: ✅ Authorized
API->>GTP: Process query
GTP->>NEO: Create session + root node
loop 8 Pipeline Stages
GTP->>LLM: Generate hypotheses / summaries
LLM-->>GTP: LLM response
GTP->>NEO: Write nodes & relationships
NEO-->>GTP: Confirmed
end
GTP->>NEO: Extract final subgraph
NEO-->>GTP: Final answer graph
GTP-->>API: Structured result
API-->>User: JSON-RPC response\n{result, confidence, graph_state}
Full documentation including API reference, configuration guide, and contribution guidelines:
Adaptive-Graph-of-Thoughts-MCP-server/
├── 📁 .github/ # CI/CD workflows (CodeQL, Dependabot)
├── 📁 agt_setup/ # Interactive setup wizard CLI
├── 📁 config/ # settings.yaml configuration
├── 📁 docs_src/ # MkDocs documentation source
├── 📁 helm/ # Kubernetes Helm chart
├── 📁 src/
│ └── 📁 adaptive_graph_of_thoughts/
│ ├── 📁 api/ # FastAPI routes & schemas
│ ├── 📁 application/ # GoTProcessor orchestrator
│ ├── 📁 domain/ # 8-stage pipeline & models
│ ├── 📁 infrastructure/ # Neo4j utilities
│ └── 📁 services/ # LLM & external API clients
├── 📁 tests/ # Comprehensive test suite
├── Dockerfile
├── docker-compose.yml
├── pyproject.toml
└── README.md
git clone https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server.git
cd Adaptive-Graph-of-Thoughts-MCP-server
poetry install
poetry run python -m agt_setup # Interactive credential setup wizard
poetry run uvicorn adaptive_graph_of_thoughts.main:app --reload
Visit http://localhost:8000/docs for the interactive API documentation.
Before running Adaptive Graph of Thoughts (either locally or via Docker if not using the provided docker-compose.prod.yml which includes Neo4j), ensure you have:
A running Neo4j Instance: Adaptive Graph of Thoughts requires a connection to a Neo4j graph database.
apoc.create.addLabels, apoc.merge.node). Without APOC, the application will not function correctly. You can find installation instructions on the official APOC website.config/settings.yaml (or corresponding environment variables) correctly points to your Neo4j instance URI, username, and password.python scripts/run_cypher_migrations.py to apply the provided Cypher migrations automatically. See Neo4j Indexing Strategy for details.Note: The provided docker-compose.yml (for development) and docker-compose.prod.yml (for production) already include a Neo4j service with the APOC library pre-configured, satisfying this requirement when using Docker Compose.
pyproject.toml, e.g., the Docker image uses Python 3.11.x or 3.12.x, 3.13.x)Clone the repository:
git clone https://github.com/SaptaDey/Adaptive-Graph-of-Thoughts-MCP-server.git
cd Adaptive-Graph-of-Thoughts-MCP-server
Install dependencies using Poetry:
poetry install
This creates a virtual environment and installs all necessary packages specified in pyproject.toml.
Activate the virtual environment:
poetry shell
Configure the application:
# Copy example configuration
cp config/settings.example.yaml config/settings.yaml
# Edit configuration as needed
vim config/settings.yaml
Set up environment variables (optional):
# Create .env file for sensitive configuration
echo "LOG_LEVEL=DEBUG" > .env
echo "API_HOST=0.0.0.0" >> .env
echo "API_PORT=8000" >> .env
In production environments, set the SECRETS_PROVIDER environment variable to
aws, gcp, or vault to fetch sensitive values from a supported secrets
manager. Optionally provide <VAR>_SECRET_NAME variables (for example
OPENAI_API_KEY_SECRET_NAME) to control the name of each secret. When a secrets
provider is configured, values for OPENAI_API_KEY, ANTHROPIC_API_KEY, and
NEO4J_PASSWORD are loaded automatically at startup.
Run the development server:
python src/adaptive_graph_of_thoughts/main.py
Alternatively, for more control:
uvicorn adaptive_graph_of_thoughts.main:app --reload --host 0.0.0.0 --port 8000
The API will be available at http://localhost:8000.
An interactive wizard is available to streamline initial configuration.
poetry run python -m agt_setup
Then visit http://localhost:8000/setup to complete the web-based steps.
Setup wizard demo GIF will appear here in the full documentation.
graph TB
subgraph "Development Environment"
A[👨💻 Developer] --> B[🐳 Docker Compose]
end
subgraph "Container Orchestration"
B --> C[📦 Adaptive Graph of Thoughts Container]
B --> D[📊 Monitoring Container]
B --> E[🗄️ Database Container]
end
subgraph "Adaptive Graph of Thoughts Application"
C --> F[⚡ FastAPI Server]
F --> G[🧠 ASR-GoT Engine]
F --> H[🔌 MCP Protocol]
end
subgraph "External Integrations"
H --> I[🤖 Claude Desktop]
H --> J[🔗 Other AI Clients]
end
style A fill:#e1f5fe
style B fill:#f3e5f5
style C fill:#e8f5e8
style F fill:#fff3e0
style G fill:#ffebee
style H fill:#f1f8e9
Quick Start with Docker Compose:
# Build and run all services
docker-compose up --build
# For detached mode (background)
docker-compose up --build -d
# View logs
docker-compose logs -f adaptive-graph-of-thoughts
Individual Docker Container:
# Build the image
docker build -t adaptive-graph-of-thoughts:latest .
# Run the container
docker run -p 8000:8000 -v $(pwd)/config:/app/config adaptive-graph-of-thoughts:latest
Production Deployment:
# Use production compose file
docker-compose -f docker-compose.prod.yml up --build -d
A minimal Helm chart is provided under helm/agot-server for
running Adaptive Graph of Thoughts on a Kubernetes cluster.
helm install agot helm/agot-server
Customize values in helm/agot-server/values.yaml to set the image repository,
resource limits, and other options.
smithery.yaml.
PORT environment variable (default 8000)./health endpoint.Dockerfile and docker-compose.prod.yml illustrate the container setup.http://localhost:8000/docshttp://localhost:8000/healthhttp://localhost:8000/mcpAdaptive Graph of Thoughts supports integration with various MCP clients:
{
"mcpServers": {
"adaptive-graph-of-thoughts": {
"command": "python",
"args": ["-m", "adaptive_graph_of_thoughts.main"],
"cwd": "/path/to/Adaptive-Graph-of-Thoughts-MCP-server",
"env": {
"NEO4J_URI": "bolt://localhost:7687",
"NEO4J_USER": "neo4j",
"NEO4J_PASSWORD": "your_password",
"MCP_TRANSPORT_TYPE": "stdio"
}
}
}
}
The primary API endpoints exposed by Adaptive Graph of Thoughts are:
MCP Protocol Endpoint: POST /mcp
asr_got.query method:
{
"jsonrpc": "2.0",
"method": "asr_got.query",
"params": {
"query": "Analyze the relationship between microbiome diversity and cancer progression.",
"parameters": {
"include_reasoning_trace": true,
"include_graph_state": false
}
},
"id": "123"
}
initialize and shutdown.Health Check Endpoint: GET /health
{
"status": "healthy",
"version": "0.1.0"
}
The advanced API endpoints previously listed (e.g., /api/v1/graph/query) are not implemented in the current version and are reserved for potential future development.
session_id)Currently, the session_id parameter available in API requests (e.g., for asr_got.query) and present in responses serves primarily to identify and track a single, complete query-response cycle. It is also used for correlating progress notifications (like got/queryProgress) with the originating query.
While the system generates and utilizes session_ids, Adaptive Graph of Thoughts does not currently support true multi-turn conversational continuity where the detailed graph state or reasoning context from a previous query is automatically loaded and reused for a follow-up query using the same session_id. Each query is processed independently at this time.
A potential future enhancement for Adaptive Graph of Thoughts is the implementation of persistent sessions. This would enable more interactive and evolving reasoning processes by allowing users to:
session_id, likely within the Neo4j database.session_id, the system could reload this saved state as the starting point for further processing.Implementing persistent sessions would involve developing robust strategies for:
This is a significant feature that could greatly enhance the interactive capabilities of Adaptive Graph of Thoughts. Contributions from the community in designing and implementing persistent session functionality are welcome.
Currently, the 8 stages of the Adaptive Graph of Thoughts reasoning pipeline are executed sequentially. For complex queries or to further optimize performance, exploring asynchronous or parallel execution for certain parts of the pipeline is a potential future enhancement.
Potential Areas for Parallelism:
HypothesisStage generates hypotheses for each dimension identified by the DecompositionStage. The process of generating hypotheses for different, independent dimensions could potentially be parallelized. For instance, if three dimensions are decomposed, three parallel tasks could work on generating hypotheses for each respective dimension.EvidenceStage, if multiple hypotheses are selected for evaluation, the "plan execution" phase (simulated evidence gathering) for these different hypotheses might be performed concurrently.Challenges and Considerations:
Implementing parallel stage execution would introduce complexities that need careful management:
GoTProcessor would become more complex.While the current sequential execution ensures a clear and manageable data flow, targeted parallelism in areas like hypothesis generation for independent dimensions could offer performance benefits for future versions of Adaptive Graph of Thoughts. This remains an open area for research and development.
Continuous integration pipelines on GitHub Actions run tests, CodeQL analysis, and Microsoft Defender for DevOps security scans.
# Run full test suite with coverage using Poetry
poetry run pytest --cov=src --cov-report=html --cov-report=term
# Or using Makefile for the default test run
make test
# Run specific test categories (using poetry)
poetry run pytest tests/unit/stages/ # Stage-specific tests
poetry run pytest tests/integration/ # Integration tests
poetry run pytest -k "test_confidence" # Tests matching pattern
# Type checking and linting (can also be run via Makefile targets: make lint, make check-types)
poetry run mypy src/ --strict # Strict type checking
poetry run ruff check . --fix # Auto-fix linting issues
poetry run ruff format . # Format code
# Pre-commit hooks (recommended)
poetry run pre-commit install # Install hooks
poetry run pre-commit run --all-files # Run all hooks (runs Ruff and MyPy)
# See Makefile for other useful targets like 'make all-checks'.
Dashboard demo GIF coming soon.
Use the vscode-agot extension to query the server from VS Code. Run the extension and execute AGoT: Ask Graph… from the Command Palette.
If the server fails to start or setup reports errors, ensure your Neo4j instance is running and the credentials in .env are correct. Consult the console output for details.
We have an exciting vision for the future of Adaptive Graph of Thoughts! Our roadmap includes plans for enhanced graph visualization, integration with more data sources like Arxiv, and further refinements to the core reasoning engine.
For more details on our planned features and long-term goals, please see our Roadmap (also available on the documentation site).
We welcome contributions! Please see our Contributing Guidelines (also available on the documentation site) for details on how to get started, our branching strategy, code style, and more.
This project is licensed under the Apache License 2.0. License.
Please see our Security Policy for reporting vulnerabilities and details on supported versions.
LLM Reasoning Framework for Scientific Research
도구
아직 도구 목록이 없습니다. 원격 서버는 첫 상태 확인 후에 도구 목록이 생깁니다.
FAQ
이 페이지에서 Cursor, Claude Desktop, Claude Code 또는 VS Code용 stdio 설정을 복사합니다. PlugMCP 프록시가 아니라 게시자의 설치 방식을 사용합니다.
이 레코드에는 필수 환경 변수가 등록되어 있지 않습니다.
Adaptive Graph Of Thoughts은(는) stdio를 통해 로컬에서 실행됩니다.
마지막 확인: 2026-10-28. LLM Reasoning Framework for Scientific Research