Domain-aware server that turns your entire microservice ecosystem into a unified in-memory graph.
It ingests code and documentation, extracts business logic, APIs, and data models, and links everything as first-class entities for fast contextual reasoning.
All knowledge is persisted in PostgreSQL for long-term querying, and the server exposes an MCP interface to plug directly into LLM workflows or other MCP-based tools.
Table of Contents
MCP server that clones and analyzes microservices to extract business rules, APIs, and data models—represented as an in-memory graph for fast reasoning.
Modern backends age into a zoo of microservices and monorepos.
domain-mcp-server centralizes business/domain knowledge, linking code,
docs, APIs, and DB models into a single structured repository for LLMs
and tooling.
What this MCP does
Git cloning via JGit (shallow clone, branch selection)
Auto-detection of project language (Java, Node.js/TypeScript, Go)
Import-based dependency graph building (no LLM)
Per-class/module Claude API analysis (language-aware prompts)
PostgreSQL-backed catalog of classes, methods, and endpoints
Stack trace correlation with graph-enhanced neighbor resolution
Language is auto-detected from project marker files: pom.xml / build.gradle for Java, package.json for Node.js/TypeScript, go.mod for Go.
Architecture
Java 21 + Spring Boot 3.3 (MCP-enabled)
JGit for repository cloning
Per-language source parsers (Java, Node.js/TypeScript, Go)
Claude API (Sonnet 4.5) for per-class business analysis (language-aware prompts)
Import-based dependency graph (no LLM needed for graph)
PostgreSQL persistence (JDBI3)
MCP stdio transport for Claude Code integration
Interacting with Claude
Once the MCP server is connected, you can talk to Claude in natural language and it will automatically pick the right tools. Below are example prompts organized by use case.
Discovering projects
What projects are indexed?
Show me all the microservices you know about.
Is the payment-service already analyzed?
Claude will call list_projects and summarize the results.
Searching within a project
Find all classes related to "Invoice" in the billing-service.
Search for anything related to "Kafka" in order-service.
What classes does payment-service have that deal with refunds?
Claude will call search_project with the project name and your keyword.
Understanding a class
What does co.fanki.order.domain.OrderService do?
Explain the purpose of PaymentGatewayClient in the payment-service.
Tell me about the OrderController, specifically in the order-service project.
Claude will call get_class_context (with optional projectName scoping) and explain the class type, business description, methods, and graph relationships.
Understanding a method
What does the placeOrder method do in co.fanki.order.domain.OrderService?
Explain the business logic of processRefund in the payment-service's RefundService.
What exceptions can chargeCustomer throw?
Claude will call get_method_context and return the description, business logic steps, exceptions, HTTP endpoint info, and parameter types.
Investigating errors from Datadog
I'm seeing a PaymentDeclinedException in production. Here's the stack trace: [paste stack trace]
Correlate this Datadog error trace and tell me what went wrong.
We got an error in co.fanki.order.domain.OrderService.placeOrder at line 92. What does that code do and what are its dependencies?
Claude will call get_stack_trace_context with the frames and explain each step in the execution path, flag missing context, and include related dependency classes.
Exploring dependencies
What does OrderService depend on?
What classes import PaymentGatewayClient?
Show me the full dependency graph around co.fanki.billing.domain.InvoiceService in the billing-service.
Claude will call get_class_dependencies and show outgoing dependencies, incoming dependents, and method parameter types.
Getting a project overview
Give me an overview of the order-service architecture.
What entry points does payment-service have?
How many controllers vs services vs repositories does billing-service have?
Claude will call get_project_overview and summarize the architecture: entry points, HTTP endpoints, class type breakdown, and project description.
Integrating with another microservice
Create a Feign client for the endpoint getStock from stock-service.
I need to call payment-service's chargeCustomer endpoint from order-service. Generate the Feign client, the request DTO, and the response DTO.
Show me the full API surface of notification-service so I can build an integration layer.
What DTOs does billing-service expect in its createInvoice endpoint? Generate them in my project.
Claude will call get_service_api and/or get_method_context to retrieve the endpoint details (HTTP method, path, parameter types, response), then generate the Feign client interface, DTOs, and any configuration needed to integrate with the target service.
Combining tools in a single conversation
You can chain multiple questions and Claude will pick the right tools automatically:
Which projects are indexed?
Search for "Stock" classes in the stock-service.
I want to connect to stock-service using the getStock method -- what does it do, what parameters does it need, and what endpoint should I call?
Show me the full API surface of stock-service so I can build a Feign client.
Claude will chain list_projects -> search_project -> get_method_context -> get_service_api across the conversation, building up context as it goes.
Datadog + Domain MCP combined workflow
When both the Datadog MCP and Domain MCP servers are connected:
Check the last 10 error traces for order-service in the past hour, correlate the logs, and explain what each class in the stack trace does.
Claude will automatically chain Datadog tools (trace_list_error_traces, log_correlate) with Domain MCP tools (get_stack_trace_context, get_class_context) to produce a full root cause analysis.
MCP Tools
The server exposes 9 MCP tools via stdio transport. All tools return JSON responses.
list_projects
List all indexed projects. Use this to check which repositories have been analyzed and are available for Datadog stack trace correlation. Includes project description derived from README.
Search for classes within a specific project by partial name. Returns matching classes with their type, description, entry point status, and source file. Use this to discover classes in a project when you don't know the exact fully qualified name.
Parameters:
Parameter
Required
Type
Description
projectName
yes
string
The project name as returned by list_projects
query
yes
string
Partial class name or keyword to search for (case-insensitive)
Response fields:
Field
Type
Description
found
boolean
Whether the project was found
projectName
string
The project name
query
string
The search query
matches
array
Matching classes
matches[].className
string
Fully qualified class name
matches[].classType
string
Class type (SERVICE, CONTROLLER, REPOSITORY, DTO, etc.), null if not enriched
matches[].description
string
Business description, null if not enriched
matches[].entryPoint
boolean
Whether the class is an entry point (controller, listener)
Get business context for a class by its fully qualified name. Returns class type, description, all methods, and project description from README. Use this when Datadog shows an error in a specific class to understand its purpose and behavior.
Parameters:
Parameter
Required
Type
Description
className
yes
string
The fully qualified class name (e.g., co.fanki.order.OrderService)
projectName
no
string
Scope the search to this project (as returned by list_projects)
Response fields:
Field
Type
Description
found
boolean
Whether the class was found
className
string
Fully qualified class name
classType
string
Class type (SERVICE, CONTROLLER, REPOSITORY, DTO, etc.)
description
string
Business description from Claude enrichment
projectDescription
string
Project description from README
methods
array
Methods in this class
methods[].name
string
Method name
methods[].description
string
Business description
methods[].businessLogic
array
Step-by-step business logic
projectUrl
string
Git repository URL
graphInfo
object
Graph relationship data (null if no graph)
graphInfo.dependencies
array
What this class imports (outgoing edges)
graphInfo.dependents
array
What imports this class (incoming edges)
graphInfo.entryPoint
boolean
Whether this class is an entry point
knownProjects
array
Available projects (populated when class not found)
{
"found": true,
"className": "co.fanki.order.domain.OrderService",
"classType": "SERVICE",
"description": "Core domain service for order lifecycle management. Handles order creation, validation, and state transitions.",
"projectDescription": "Microservice for order lifecycle management",
"methods": [
{
"name": "placeOrder",
"description": "Creates a new order for a customer after validating stock and payment",
"businessLogic": [
"Validate order items against inventory",
"Calculate total with discounts",
"Reserve stock",
"Process payment via PaymentService",
"Persist order with PENDING status"
]
},
{
"name": "cancelOrder",
"description": "Cancels an existing order and releases reserved stock",
"businessLogic": [
"Load order by ID",
"Verify order is cancellable (not shipped)",
"Release reserved stock",
"Initiate refund if paid",
"Update status to CANCELLED"
]
}
],
"projectUrl": "[email protected]:fanki/order-service.git",
"graphInfo": {
"dependencies": [
"co.fanki.order.domain.OrderRepository",
"co.fanki.order.domain.PaymentService",
"co.fanki.order.domain.InventoryClient"
],
"dependents": [
"co.fanki.order.application.OrderController"
],
"entryPoint": false
},
"knownProjects": [],
"message": null
}
get_method_context
Get detailed context for a specific method, including business logic, dependencies, exceptions, HTTP endpoint info, and project description from README. Use this when Datadog shows an error in a specific method to understand what it does and why it might fail.
Parameters:
Parameter
Required
Type
Description
className
yes
string
The fully qualified class name
methodName
yes
string
The method name
projectName
no
string
Scope the search to this project (as returned by list_projects)
Response fields:
Field
Type
Description
found
boolean
Whether the method was found
className
string
Fully qualified class name
methodName
string
Method name
httpEndpoint
string
HTTP endpoint (e.g., POST /api/orders), null if not an endpoint
description
string
Business description
projectDescription
string
Project description from README
businessLogic
array
Step-by-step business logic
exceptions
array
Exceptions this method may throw
sourceFile
string
Relative source file path
lineNumber
number
Line number in source file
projectUrl
string
Git repository URL
parameterTypes
array
Method parameter types resolved from the project graph
{
"found": true,
"className": "co.fanki.order.domain.OrderService",
"methodName": "placeOrder",
"httpEndpoint": "POST /api/orders",
"description": "Creates a new order for a customer after validating stock and payment",
"projectDescription": "Microservice for order lifecycle management",
"businessLogic": [
"Validate order items against inventory",
"Calculate total with discounts",
"Reserve stock",
"Process payment via PaymentService",
"Persist order with PENDING status"
],
"exceptions": [
"InsufficientStockException",
"PaymentDeclinedException"
],
"sourceFile": "src/main/java/co/fanki/order/domain/OrderService.java",
"lineNumber": 85,
"projectUrl": "[email protected]:fanki/order-service.git",
"parameterTypes": [
{
"position": 0,
"typeName": "co.fanki.order.domain.CreateOrderRequest"
}
],
"knownProjects": [],
"message": null
}
get_stack_trace_context
Primary tool for Datadog error correlation. Takes a full stack trace (array of className/methodName/lineNumber frames) and returns business context for each frame, plus project description from README. Use this IMMEDIATELY after getting error traces or stack traces from Datadog to understand the execution path and root cause.
{
"executionPath": [
{
"order": 1,
"className": "co.fanki.order.application.OrderController",
"methodName": "createOrder",
"classType": "CONTROLLER",
"description": "Validates input and delegates to OrderService",
"businessLogic": ["Validate request body", "Delegate to OrderService.placeOrder"],
"httpEndpoint": "POST /api/orders",
"found": true
},
{
"order": 2,
"className": "co.fanki.order.domain.OrderService",
"methodName": "placeOrder",
"classType": "SERVICE",
"description": "Creates a new order after validating stock and payment",
"businessLogic": ["Validate items", "Calculate total", "Reserve stock", "Process payment", "Persist order"],
"httpEndpoint": null,
"found": true
},
{
"order": 3,
"className": "co.fanki.order.domain.PaymentService",
"methodName": "processPayment",
"classType": "SERVICE",
"description": "Charges the customer via the payment gateway",
"businessLogic": ["Validate card", "Call payment gateway", "Handle response"],
"httpEndpoint": null,
"found": true
},
{
"order": 4,
"className": "org.springframework.web.servlet.DispatcherServlet",
"methodName": "doDispatch",
"classType": null,
"description": null,
"businessLogic": [],
"httpEndpoint": null,
"found": false
}
],
"missingContext": [
{
"className": "org.springframework.web.servlet.DispatcherServlet",
"methodName": "doDispatch",
"lineNumber": 1067
}
],
"projectUrl": "[email protected]:fanki/order-service.git",
"projectDescription": "Microservice for order lifecycle management",
"relatedDependencies": [
{
"order": 1,
"className": "co.fanki.order.domain.OrderRepository",
"methodName": "save",
"classType": "REPOSITORY",
"description": "Persists order entities to the database",
"businessLogic": ["Insert order into orders table"],
"httpEndpoint": null,
"found": true
}
]
}
get_class_dependencies
Get the dependency graph around a class. Returns what this class imports (dependencies), what imports it (dependents), and method parameter types. Use this to understand how a class connects to the rest of the system.
Parameters:
Parameter
Required
Type
Description
className
yes
string
The fully qualified class name
projectName
no
string
Scope the search to this project (as returned by list_projects)
{
"found": true,
"className": "co.fanki.order.domain.OrderService",
"entryPoint": false,
"dependencies": [
{
"className": "co.fanki.order.domain.OrderRepository",
"classType": "REPOSITORY",
"description": "Persists order entities to the database"
},
{
"className": "co.fanki.order.domain.PaymentService",
"classType": "SERVICE",
"description": "Charges the customer via the payment gateway"
}
],
"dependents": [
{
"className": "co.fanki.order.application.OrderController",
"classType": "CONTROLLER",
"description": "REST endpoints for order operations"
}
],
"methodParameterTypes": [
{
"methodName": "placeOrder",
"parameterTypes": [
{
"className": "co.fanki.order.domain.CreateOrderRequest",
"classType": "DTO",
"description": "Request payload for creating a new order"
}
]
}
],
"message": null
}
get_project_overview
Get a structural overview of an indexed project. Returns entry points (controllers, listeners), HTTP endpoints, class type breakdown, and project description. Use this to understand the architecture before drilling into specific classes.
Parameters:
Parameter
Required
Type
Description
projectName
yes
string
The project name as returned by list_projects
Response fields:
Field
Type
Description
found
boolean
Whether the project was found
projectName
string
Project name
repositoryUrl
string
Git repository URL
description
string
Project description from README
totalClasses
number
Total number of indexed classes
totalEntryPoints
number
Number of entry points in the graph
classTypeBreakdown
object
Count per class type (e.g., {"SERVICE": 5, "CONTROLLER": 2})
Get the public API surface of an indexed microservice. Returns all HTTP endpoints grouped by controller, with parameter types (DTOs), descriptions, business logic, and exceptions. Use this when you need to integrate with or call another microservice.
{
"found": true,
"projectName": "order-service",
"repositoryUrl": "[email protected]:fanki/order-service.git",
"description": "Microservice for order lifecycle management",
"controllers": [
{
"className": "co.fanki.order.application.OrderController",
"description": "REST endpoints for order operations",
"endpoints": [
{
"methodName": "createOrder",
"httpMethod": "POST",
"httpPath": "/api/orders",
"description": "Creates a new order for a customer",
"businessLogic": [
"Validate request body",
"Delegate to OrderService.placeOrder",
"Return created order with 201"
],
"exceptions": ["InvalidOrderException"],
"parameters": [
{
"position": 0,
"className": "co.fanki.order.domain.CreateOrderRequest",
"classType": "DTO",
"description": "Request payload for creating a new order"
}
]
},
{
"methodName": "getOrder",
"httpMethod": "GET",
"httpPath": "/api/orders/{id}",
"description": "Retrieves an order by its ID",
"businessLogic": [
"Parse order ID from path",
"Query OrderRepository",
"Return 404 if not found"
],
"exceptions": ["OrderNotFoundException"],
"parameters": []
},
{
"methodName": "cancelOrder",
"httpMethod": "PUT",
"httpPath": "/api/orders/{id}/cancel",
"description": "Cancels an existing order and releases reserved stock",
"businessLogic": [
"Load order by ID",
"Verify order is cancellable",
"Delegate to OrderService.cancelOrder",
"Return updated order"
],
"exceptions": ["OrderNotFoundException", "OrderNotCancellableException"],
"parameters": []
}
]
}
],
"message": null
}
graph_query
Query the in-memory project graph using a colon-separated DSL. Supports listing endpoints, classes, and entry points; navigating to any vertex (class) by name; sub-navigation (methods, dependencies, dependents); projection modifiers (+logic, +dependencies); and existence checks (?methodName). All queries resolve from memory, no DB access. See Graph Query DSL for full syntax documentation.
{
"resultType": "check",
"project": "order-service",
"count": 1,
"results": [
{
"className": "co.fanki.order.application.OrderController",
"check": "createOrder",
"exists": true,
"methodName": "createOrder",
"description": "Creates a new order for a customer",
"httpEndpoint": "POST /api/orders"
}
]
}
REST-Only Endpoints
These operations are available via REST API (port 8080) but not as MCP tools. See the Indexing Projects section for detailed usage.
Graph Query DSL
The graph query endpoint (POST /api/graph/query) provides a colon-separated DSL for querying the in-memory project graph. All queries are resolved entirely from memory — no database access at query time.
Syntax
project:target[:navigation]*[:+include]*[:?check]
A query is a colon-separated string where:
The first segment is always the project name.
The second segment is the target: either a keyword (endpoints, classes, entrypoints) or any vertex (class name) in the graph.
Subsequent segments are tokenized by their prefix.
Token Types
Prefix
Token Type
Description
(none)
NAVIGATE
Traverses the graph (e.g., methods, dependencies, UserService)
+
INCLUDE
Projection modifier — adds extra data to the response (e.g., +logic, +dependencies)
?
CHECK
Existence predicate — checks if a method exists on a vertex (e.g., ?createUser)
Keywords
These reserved words act as list operations when used as the first navigation target:
Keyword
Description
endpoints
List all HTTP endpoints across the project
classes
List all classes/modules in the project
entrypoints
List entry point classes (controllers, listeners)
Any other value is resolved as a vertex (class name) in the graph, with fuzzy matching (exact, suffix, contains).
Examples
Listing endpoints
# All HTTP endpoints in the project
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:endpoints"}'
# Endpoints with business logic included
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:endpoints:+logic"}'
# All classes
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:classes"}'
# Classes with dependencies and dependents
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:classes:+dependencies:+dependents"}'
# Classes with method summaries
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:classes:+methods"}'
Listing entry points
# All entry points (controllers, listeners)
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:entrypoints"}'
# Entry points with business logic on their endpoints
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:entrypoints:+logic"}'
Navigating to a vertex (class)
Navigate directly to any class by name — no class: prefix needed. Supports simple name, FQCN, or partial match.
# Class overview (methods summary, dependencies, dependents)
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderService"}'
# Same with fully qualified name
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:co.fanki.order.domain.OrderService"}'
# Class overview with business logic in method summaries
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderService:+logic"}'
Response:
{
"resultType": "class",
"project": "order-service",
"count": 1,
"results": [
{
"className": "co.fanki.order.domain.OrderService",
"classType": "SERVICE",
"description": "Core domain service for order lifecycle management",
"sourceFile": "src/main/java/co/fanki/order/domain/OrderService.java",
"entryPoint": false,
"dependencies": ["co.fanki.order.domain.OrderRepository", "co.fanki.order.domain.PaymentService"],
"dependents": ["co.fanki.order.application.OrderController"],
"methods": [
{
"methodName": "placeOrder",
"description": "Creates a new order after validating stock and payment",
"httpEndpoint": null
},
{
"methodName": "cancelOrder",
"description": "Cancels an existing order and releases reserved stock",
"httpEndpoint": null
}
]
}
]
}
Sub-navigation on a vertex
# All methods of a class
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderService:methods"}'
# Methods with business logic
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderService:methods:+logic"}'
# Single method detail
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderController:method:createOrder"}'
# Outgoing dependencies
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderService:dependencies"}'
# Incoming dependents (who depends on this class)
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderService:dependents"}'
Existence checks (?)
Check if a class has a specific method. Returns exists: true/false with method details when found.
# Does OrderController have a createOrder method?
curl -X POST http://localhost:8080/api/graph/query \
-H "Content-Type: application/json" \
-d '{"query": "order-service:OrderController:?createOrder"}'
Response when method exists:
{
"resultType": "check",
"project": "order-service",
"count": 1,
"results": [
{
"className": "co.fanki.order.application.OrderController",
"check": "createOrder",
"exists": true,
"methodName": "createOrder",
"description": "Creates a new order for a customer",
"httpEndpoint": "POST /api/orders"
}
]
}
Directory where Git repositories are cloned & cached.
Running
REST API (standalone)
mvn spring-boot:run
Starts the web server on port 8080 with REST endpoints for managing projects and querying context.
Docker
docker build -t domain-mcp-server .
docker run -p 8080:8080 domain-mcp-server
Kubernetes
Deploy with env vars for DB, SSH key, LLM key.
Indexing Projects
Before the MCP tools can return context about your code, you need to index your repositories through the REST API. The recommended setup is to run the analysis service as a standalone process (or container) with access to the Claude API and SSH keys, and then point the MCP server at the same PostgreSQL database for read-only querying.
Swagger UI
Once the server is running, the full REST API documentation is available at:
http://localhost:8080/swagger-ui/index.html
REST API Endpoints
Endpoint
Method
Description
/api/projects/analyze
POST
Analyze a git repository and index all classes and methods
/api/projects
GET
List all analyzed projects with metadata
/api/projects/{id}/rebuild-graph
POST
Rebuild the dependency graph without re-running Claude enrichment
/api/context/class/{className}
GET
Get class context by fully qualified name
/api/context/class?className=
GET
Alternative class context endpoint (query param)
/api/context/method?className=&methodName=
GET
Get method context with business logic and dependencies
The analysis service and the MCP server share the same PostgreSQL database but serve different purposes:
+-----------------------+
| Analysis Service |
| (REST API, port 8080)|
| ANTHROPIC_API_KEY |
| GIT_SSH_KEY_PATH |
+-----------+-----------+
|
| writes
v
+-----------------------+
| PostgreSQL |
| domain_mcp schema |
+-----------+-----------+
|
| reads
v
+-----------------------+
| MCP Server (stdio) |
| Claude Code plugin |
| No API key needed |
+-----------------------+
Analysis Service: runs as a standalone service (or Docker container). Needs ANTHROPIC_API_KEY and GIT_SSH_KEY_PATH to clone repos and analyze code with Claude. Exposes the REST API on port 8080.
MCP Server: runs as a stdio process launched by Claude Code. Only needs database credentials to read the indexed data. Does not need API keys or SSH access.
This separation means you can run the analysis once (or on a schedule), and the MCP server stays lightweight and fast.
Claude Code MCP Setup
The server supports MCP stdio transport for direct integration with Claude Code. The MCP server only needs database credentials to read indexed data — it does not require an Anthropic API key or SSH keys (see Recommended architecture).
1. Build the JAR
mvn clean package -DskipTests
2. Ensure PostgreSQL is running
The MCP server connects to the same database as the REST API. Make sure PostgreSQL is running and the domain_mcp schema exists.
Replace /absolute/path/to/ with the actual path to the JAR on your machine. Only database credentials are needed — the MCP server reads from the same PostgreSQL database populated by the analysis service.
4. Verify the connection
Restart Claude Code. The 9 domain-mcp-server tools (list_projects, search_project, get_class_context, get_method_context, get_stack_trace_context, get_class_dependencies, get_project_overview, get_service_api, graph_query) should appear in your available tools.
How it works
The mcp Spring profile activates stdio transport and redirects all logs to stderr
stdout is reserved exclusively for JSON-RPC messages
REST endpoints remain available on port 8080 for populating data via HTTP
Both transports share the same database and service layer
MCP server that clones and analyzes microservices to extract business rules, APIs, and data models—represented as an in-memory graph for fast reasoning.
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
Domain ต้องใช้ API key ไหม?
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Domain ใช้ทรานสปอร์ตแบบใด?
Domain ทำงานแบบโลคัลผ่าน stdio
Domain ถูกตรวจสอบล่าสุดเมื่อใด?
ตรวจสอบล่าสุดเมื่อ 2026-10-27 MCP server that clones and analyzes microservices to extract business rules, APIs, and data models—represented as an in-memory graph for fast reasoning.