MCP 서버 및 MCP 앱을 Python과 FastMCP로 구축하기 위한 프로덕션 지향 템플릿으로, 클린 아키텍처, 의존성 역전, 관심사 분리, 그리고 현대적인 Python 관행을 따릅니다.
이 프로젝트는 C# / .NET 출신 개발자들을 위한 학습 참고 자료로도 활용됩니다.
목표는 단순히 동작하는 MCP 서버를 만드는 것이 아니라, 유지보수 가능하고, 테스트 가능하며, 확장 가능하고, 외부 프레임워크와 서비스로부터 독립적인 서버를 만드는 것입니다.
이 템플릿은 다음을 사용하여 MCP 애플리케이션을 구축하는 방법을 보여줍니다:
Python
FastMCP
Streamable HTTP 전송
Stateless HTTP
MCP 도구(Tools)
MCP 리소스(Resources)
MCP 프롬프트(Prompts)
MCP 앱 / 앱 UI
클린 아키텍처
의존성 역전
리포지토리 패턴
유스 케이스
Pydantic 모델
외부 REST API 통합
환경 기반 구성
비동기 HTTP 통신
의존성 주입 / 컴포지션
중앙 집중식 오류 처리
구조화된 애플리케이션 오류
로깅
단위 테스트
통합 테스트
샘플 도메인은 전자상거래 애플리케이션입니다.
제품은 공개 외부 API에서 가져와 MCP를 통해 노출됩니다.
애플리케이션은 다음과 같은 작업을 지원하도록 발전할 것입니다:
제품 검색
제품 상세 보기
장바구니에 제품 추가
장바구니 보기
장바구니에서 제품 제거
MCP 앱 UI는 호환되는 MCP 호스트 내에서 대화형 경험을 제공할 것입니다.
이 프로젝트는 클린 아키텍처 원칙을 따릅니다.
MCP HOST
Claude / Copilot / etc.
|
| MCP over HTTP
v
+---------------------------------------------------------+
| PRESENTATION |
| |
| FastMCP Server |
| MCP Tools |
| MCP Resources |
| MCP Prompts |
| MCP App UI |
| Error Boundary |
+---------------------------+-----------------------------+
|
v
+---------------------------------------------------------+
| APPLICATION |
| |
| Use Cases |
| |
| GetProductUseCase |
| SearchProductsUseCase |
| AddProductToCartUseCase |
| GetCartUseCase |
+---------------------------+-----------------------------+
|
v
+---------------------------------------------------------+
| DOMAIN |
| |
| Entities / Models |
| |
| Product |
| Cart |
| |
| Repository Contracts |
| |
| ProductRepository |
| CartRepository |
| |
| Domain Errors |
+---------------------------+-----------------------------+
^
|
+---------------------------+-----------------------------+
| INFRASTRUCTURE |
| |
| External API implementations |
| HTTP clients |
| Configuration |
| Persistence adapters |
| |
| DummyJsonProductRepository |
| DummyJsonCartRepository |
+---------------------------+-----------------------------+
|
v
External REST API가장 중요한 규칙은 다음과 같습니다:
Presentation ---> Application ---> Domain
^
|
Infrastructure ----------+의존성은 핵심 애플리케이션을 향합니다.
도메인은 절대 다음에 의존해서는 안 됩니다:
FastMCP
HTTP libraries
Uvicorn
DummyJSON
Claude
Copilot
databases
environment variables
MCP App UI예를 들어:
MCP Tool
|
v
GetProductUseCase
|
v
ProductRepository
^
|
DummyJsonProductRepository
|
v
DummyJSON REST APIGetProductUseCase는 ProductRepository 추상화에 대해 알고 있습니다.
제품이 HTTP나 DummyJSON을 사용하여 검색된다는 사실은 알지 못합니다.
이를 통해 다음을 허용합니다:
DummyJSON나중에 다음으로 교체할 수 있습니다:
SQL Server
PostgreSQL
MongoDB
another REST API
mock repository애플리케이션 유스 케이스를 변경하지 않고도 말입니다.
프로젝트는 다음 구조로 발전할 것입니다:
mcp-clean-architecture/
|
|-- src/
| |
| |-- domain/
| | |
| | |-- entities/
| | | |-- __init__.py
| | | |-- product.py
| | | `-- cart.py
| | |
| | |-- repositories/
| | | |-- __init__.py
| | | |-- product_repository.py
| | | `-- cart_repository.py
| | |
| | `-- errors/
| | |-- __init__.py
| | `-- domain_errors.py
| |
| |-- application/
| | |
| | |-- use_cases/
| | | |-- __init__.py
| | | |-- get_product.py
| | | |-- search_products.py
| | | |-- add_product_to_cart.py
| | | `-- get_cart.py
| | |
| | `-- errors/
| | |-- __init__.py
| | `-- application_errors.py
| |
| |-- infrastructure/
| | |
| | |-- config/
| | | |-- __init__.py
| | | `-- environment.py
| | |
| | |-- http/
| | |
| | |-- repositories/
| | | |-- __init__.py
| | | |-- dummy_json_product_repository.py
| | | `-- dummy_json_cart_repository.py
| | |
| | `-- errors/
| | |-- __init__.py
| | `-- infrastructure_errors.py
| |
| `-- presentation/
| |
| `-- mcp/
| |-- __init__.py
| |-- server.py
| |
| |-- tools/
| |
| |-- resources/
| |
| |-- prompts/
| |
| `-- apps/
|
|-- tests/
| |
| |-- unit/
| `-- integration/
|
|-- .env.example
|-- .gitignore
|-- .python-version
|-- pyproject.toml
|-- uv.lock
`-- README.md폴더는 실제 책임이 있을 때 도입되어야 합니다.
템플릿은 단지 레이어를 더 많이 만들기 위해 추상화를 만들어서는 안 됩니다.
Related MCP server: NitroStack
핵심 비즈니스 개념과 계약을 포함합니다.
예:
Product
Cart
ProductRepository
CartRepository
ProductNotFoundError
CartError도메인은 외부 세계가 애플리케이션과 통신하는 방식을 알지 못한 채 비즈니스 개념을 포함해야 합니다.
애플리케이션 특정 워크플로우와 유스 케이스를 포함합니다.
예:
GetProductUseCase
SearchProductsUseCase
AddProductToCartUseCase
GetCartUseCase유스 케이스는 도메인 추상화를 조정합니다.
외부 API를 직접 호출해서는 안 됩니다.
class GetProductUseCase:
def execute(self, product_id: int):
requests.get(
f"https://external-api/products/{product_id}"
)유스 케이스는 이제 다음을 알게 됩니다:
HTTP가 존재한다는 것
어떤 HTTP 라이브러리가 사용되는지
어떤 외부 제공자가 사용되는지
제공자 URL이 어떻게 동작하는지
class GetProductUseCase:
def __init__(self, repository: ProductRepository):
self.repository = repository
def execute(self, product_id: int) -> Product:
return self.repository.get_by_id(product_id)이제 유스 케이스는 계약만 알게 됩니다:
ProductRepository외부 기술적 관심사에 대한 구현을 포함합니다.
예:
HTTP clients
REST APIs
repositories
databases
cache
environment configuration
external service adapters예를 들어:
ProductRepository
^
|
DummyJsonProductRepository인프라스트럭처는 도메인 추상화를 구현합니다.
도메인은 인프라스트럭처에 의존하지 않습니다.
MCP 특정 진입점을 포함합니다.
예:
FastMCP Server
MCP Tools
MCP Resources
MCP Prompts
MCP AppsMCP 도구는 얇게 유지되어야 합니다.
그 책임은 주로 다음과 같습니다:
MCP Request
|
v
Validate / map input
|
v
Use Case
|
v
Map result
|
v
MCP Response비즈니스 로직은 MCP 데코레이터 안에 있어서는 안 됩니다.
MCP와 FastMCP는 서로 다른 개념입니다.
MCP
|
`-- Protocol
FastMCP
|
`-- Python framework implementing MCP애플리케이션은 Streamable HTTP를 통해 MCP를 사용합니다.
MCP Host
|
| Streamable HTTP
v
http://localhost:8000/mcp
|
v
FastMCP Server서버는 기본적으로 stateless HTTP로 실행되도록 구성됩니다.
모델이 실행할 수 있는 작업입니다.
예:
get_product
search_products
add_product_to_cart
get_cart
remove_product_from_cart개념적으로:
LLM
|
| tool call
v
MCP Tool
|
v
Use Case리소스는 MCP 호스트가 읽을 수 있는 데이터 또는 컨텍스트를 노출합니다.
애플리케이션 비즈니스 로직의 대체물이 되어서는 안 됩니다.
프롬프트는 MCP를 통해 재사용 가능한 프롬프트 템플릿을 제공합니다.
MCP / 프레젠테이션 경계에 속합니다.
MCP 앱은 호환되는 MCP 호스트가 MCP 기능과 연관된 대화형 UI를 표시할 수 있게 합니다.
우리의 전자상거래 예제는 결국 개념적으로 다음과 유사한 것을 렌더링할 것입니다:
+--------------------------------+
| Product |
| |
| Smartphone |
| |
| $799.99 |
| |
| [ Add to cart ] |
+---------------+----------------+
|
v
MCP Tool Call
|
v
AddProductToCartUseCase
|
v
CartRepository중요한 아키텍처 규칙은 다음과 같습니다:
MCP 앱 UI는 프레젠테이션 관심사입니다.
UI는 비즈니스 규칙을 구현해서는 안 됩니다.
예를 들어, 다음을 클릭하면:
[ Add to cart ]다음이 결과로 나와야 합니다:
MCP App UI
|
v
MCP Tool
|
v
AddProductToCartUseCase
|
v
CartRepositoryUI는 인프라스트럭처를 직접 조작하지 않습니다.
런타임 구성은 하드코딩되는 대신 환경 변수에서 와야 합니다.
현재 변수:
MCP_SERVER_TRANSPORT
MCP_SERVER_HOST
MCP_SERVER_PORT
MCP_STATELESS_HTTP예:
$env:MCP_SERVER_PORT="9000"구성 흐름은 다음과 같습니다:
Operating System / Container
|
| Environment Variables
v
EnvironmentSettings
|
v
server.py
|
v
FastMCP이를 통해 동일한 애플리케이션 코드가 다음에서 실행될 수 있습니다:
Local
Development
Test
Staging
Production
Docker
Kubernetes
Cloud environments다른 구성으로 말입니다.
비밀은 절대 Git에 커밋되어서는 안 됩니다.
__init__.py는 Python 패키지의 공개 API를 정의하는 데 사용될 수 있습니다.
예를 들어:
from infrastructure.config.environment import EnvironmentSettings
__all__ = [
"EnvironmentSettings",
]소비자는 다음을 사용할 수 있습니다:
from infrastructure.config import EnvironmentSettings대신에:
from infrastructure.config.environment import EnvironmentSettings이것은 내부 파일 구조에 대한 결합도를 줄입니다.
개념적으로 이것은 TypeScript의:
index.ts배럴 내보내기와 유사합니다.
__all__은 의도된 공개 API를 정의합니다.
C#의 public이나 private과 같은 접근 한정자가 아닙니다.
이 프로젝트는 또한 .NET 개발자가 Python을 배우는 데 도움을 주기 위해 설계되었습니다.
Python | C# 개념 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 대략 |
|
|
|
|
|
|
리포지토리 | 종종 |
| 대략 |
|
|
|
|
|
|
| 생성자 |
| 패키지 초기화 / 배럴 내보내기와 유사한 목적 |
Pydantic | 타입 모델 + 검증/직렬화 |
| 사용에 따라 속성/미들웨어 동작과 개념적으로 유사함 |
새로운 Python 개념이 도입될 때, 유용한 경우 해당 C# 등가물이 문서화되어야 합니다.
구조화된 모델은 검증과 직렬화가 유용한 곳에서 Pydantic을 사용합니다.
예:
from typing import Annotated
from pydantic import BaseModel
class Product(BaseModel):
id: Annotated[int, "Product identifier"]
title: Annotated[str, "Product title"]
description: Annotated[str, "Product description"]
price: Annotated[float, "Product price"]
thumbnail: Annotated[str, "Product thumbnail URL"]Pydantic은 다음을 제공합니다:
validation
type coercion
serialization
JSON-compatible output
JSON Schema generation리포지토리는 데이터 또는 외부 시스템에 대한 추상화를 나타냅니다.
예:
from abc import ABC, abstractmethod
from domain.entities import Product
class ProductRepository(ABC):
@abstractmethod
def get_by_id(self, product_id: int) -> Product:
passC# 개발자에게 이것은 개념적으로 다음과 유사합니다:
public interface IProductRepository
{
Product GetById(int productId);
}구체적인 인프라스트럭처 구현은 실제 동작을 제공할 수 있습니다:
ProductRepository
^
|
DummyJsonProductRepository외부 API는 인프라스트럭처에서 접근해야 합니다.
초기 구현은 전자상거래 예제에 공개 DummyJSON API를 사용합니다.
아키텍처는 애플리케이션 유스 케이스가 DummyJSON에 직접 의존하는 것을 방지합니다.
Application
|
v
ProductRepository
^
|
Infrastructure implementation
|
v
DummyJSON이를 통해 외부 제공자는 Application 또는 Domain 레이어를 다시 작성하지 않고도 나중에 교체할 수 있습니다.
이 프로젝트는 클린 아키텍처와 일반적인 .NET 예외 처리 패턴에서 영감을 받은 중앙 집중식 예외 계층 구조를 사용합니다.
목표는 다음을 구분하는 것입니다:
expected business failures
vs
technical/infrastructure failures공통의 구조화된 오류 계약을 제공하면서 말입니다.
AppError
|
|-- DomainError
| |
| |-- ProductNotFoundError
| `-- CartError
|
|-- ValidationError
|
`-- InfrastructureError
|
|-- ExternalAPIError
`-- ExternalAPITimeoutError모든 알려진 애플리케이션 오류는 궁극적으로 다음에서 파생됩니다:
AppErrorfrom typing import Any
class AppError(Exception):
error_code: str = "UNKNOWN_ERROR"
def __init__(
self,
message: str,
details: dict[str, Any] | None = None,
):
self.message = message
self.details = details or {}
super().__init__(message)
def to_dict(self) -> dict:
return {
"error_code": self.error_code,
"error_type": self.__class__.__name__,
"message": self.message,
"details": self.details,
}개념적으로 이것은 C#과 유사합니다:
public abstract class AppException : Exception
{
public string ErrorCode { get; }
protected AppException(
string message,
string errorCode)
: base(message)
{
ErrorCode = errorCode;
}
}도메인 오류는 예상된 비즈니스 실패를 나타냅니다.
예:
Product does not exist
Cart is empty
Product cannot be added to the cart
Requested quantity violates a business rule예:
class DomainError(AppError):
error_code = "DOMAIN_ERROR"
class ProductNotFoundError(DomainError):
error_code = "PRODUCT_NOT_FOUND"
def __init__(self, product_id: int):
super().__init__(
message=f"Product '{product_id}' was not found.",
details={
"product_id": product_id,
},
)개념적으로 다음과 유사합니다:
public class ProductNotFoundException : DomainException
{
public int ProductId { get; }
public ProductNotFoundException(int productId)
: base($"Product '{productId}' was not found.")
{
ProductId = productId;
}
}검증 오류는 잘못된 애플리케이션 입력 또는 위반된 제약 조건을 나타냅니다.
예:
Invalid product ID
Quantity must be greater than zero
Missing required input
Invalid cart operation이것들은 예상된 실패입니다.
MCP 호스트 또는 LLM이 무엇을 수정해야 하는지 이해할 수 있도록 충분한 구조화된 정보를 제공해야 합니다.
인프라스트럭처 오류는 기술적 의존성과 관련된 실패를 나타냅니다.
예:
External API unavailable
HTTP timeout
Connection failure
Unexpected downstream response
Database unavailable예를 들어:
class InfrastructureError(AppError):
error_code = "INFRASTRUCTURE_ERROR"
class ExternalAPIError(InfrastructureError):
error_code = "EXTERNAL_API_ERROR"도메인은 인프라스트럭처 예외에 의존해서는 안 됩니다.
원시 라이브러리 예외는 전체 애플리케이션을 통해 누출되어서는 안 됩니다.
예를 들어:
httpx.TimeoutException
|
v
ExternalAPITimeoutError
|
v
Application / Presentation대신에:
httpx.TimeoutException
|
+---------------------> MCP Host인프라스트럭처는 적절할 때 저수준 기술적 실패를 변환하는 책임이 있습니다.
예를 들어:
HTTP 404 from product provider
|
v
ProductNotFoundError
HTTP timeout
|
v
ExternalAPITimeoutError
HTTP 500
|
v
ExternalAPIError이것은 애플리케이션의 나머지 부분이 특정 HTTP 라이브러리에 결합되는 것을 방지합니다.
MCP 도구는 중복된 오류 처리를 포함해서는 안 됩니다.
피해야 할 것:
@mcp.tool
def tool_one():
try:
...
except AppError:
...
@mcp.tool
def tool_two():
try:
...
except AppError:
...
@mcp.tool
def tool_three():
try:
...
except AppError:
...원하는 아키텍처는 다음과 같습니다:
MCP Host
|
v
Presentation Error Boundary
|
v
MCP Tool
|
v
Use Case
|
v
Domain / Repository알려진 애플리케이션 오류는 구조화된 MCP 친화적 오류로 변환될 수 있습니다.
예상치 못한 예외는 다음을 수행해야 합니다:
logged
|
v
converted to generic internal error
|
v
returned without sensitive details이것은 개념적으로 ASP.NET Core와 유사합니다:
Python / MCP ASP.NET Core
AppError AppException
DomainError DomainException
InfrastructureError InfrastructureException
central error boundary IExceptionHandler / Middleware
raise throw
except catch오류는 유용할 때 구조화된 정보를 포함해야 합니다.
예:
{
"error_code": "PRODUCT_NOT_FOUND",
"error_type": "ProductNotFoundError",
"message": "Product '123' was not found.",
"details": {
"product_id": 123
}
}구조화된 오류는 다음을 개선합니다:
MCP 클라이언트 동작
LLM 추론
로깅
관찰 가능성
자동화된 테스트
디버깅
원시 인프라스트럭처 예외를 MCP 클라이언트에 직접 노출하지 마십시오.
모든 MCP 도구에 try/except 블록을 중복하지 마십시오.
예상된 비즈니스 실패에는 특정 도메인 오류를 사용하십시오.
잘못된 입력과 위반된 제약 조건에는 검증 오류를 사용하십시오.
외부 기술적 실패를 애플리케이션 특정 오류로 변환하십시오.
details를 통해 유용한 구조화된 컨텍스트를 보존하십시오.
애플리케이션 경계에서 예상치 못한 예외를 기록하십시오.
비밀, 토큰, 스택 추적 또는 민감한 인프라스트럭처 세부 정보를 MCP 클라이언트에 절대 노출하지 마십시오.
클라이언트와 자동화된 테스트가 의존할 수 있도록 오류 코드를 안정적으로 유지하십시오.
프레젠테이션은 애플리케이션 오류를 MCP 친화적 응답으로 변환하는 책임이 있습니다.
의존성은 명시적이어야 합니다.
예를 들어:
DummyJsonProductRepository
|
v
GetProductUseCase
|
v
MCP Tool컴포지션/루트 배선은 도메인 내부가 아닌 애플리케이션 진입점 근처에 속합니다.
프로젝트는 실용적인 경우 숨겨진 전역 의존성을 피해야 합니다.
이것은 애플리케이션이 성장함에 따라 점진적으로 도입될 것입니다.
아키텍처는 다음 없이 비즈니스 동작을 테스트할 수 있어야 합니다:
starting FastMCP
calling DummyJSON
opening an HTTP port
running MCP App UI예를 들어:
Unit Test
|
v
GetProductUseCase
|
v
FakeProductRepository이것은 유스 케이스를 독립적으로 테스트 가능하게 만듭니다.
단위 테스트는 다음에 초점을 맞춰야 합니다:
Domain behavior
Use Cases
Validation
Error handling가짜 또는 목 의존성을 사용하여 말입니다.
통합 테스트는 경계를 별도로 검증할 수 있습니다:
Infrastructure
|
v
DummyJSON API그리고:
MCP Client
|
v
FastMCP Server이 분리는 외부 API 동작이 모든 비즈니스 테스트를 불안정하게 만드는 것을 방지합니다.
요구 사항:
Python 3.12+
uv의존성 설치/동기화:
uv syncMCP 서버 실행:
uv run python -m presentation.mcp.server기본 엔드포인트:
http://localhost:8000/mcp프로젝트는 다음을 사용합니다:
.venv/격리된 Python 의존성을 위해.
uv는 프로젝트 환경을 자동으로 관리합니다.
명령은 일반적으로 다음을 사용하여 실행해야 합니다:
uv run ...예를 들어:
uv run python --version이렇게 하면 전역에 설치된 프로젝트 종속성에 의존하지 않게 됩니다.
이 템플릿을 확장할 때:
MCP 관련 코드는 Presentation에 유지합니다.
비즈니스 워크플로는 Application에 유지합니다.
비즈니스 모델과 계약은 가능한 경우 프레임워크와 독립적으로 유지합니다.
외부 통합은 Infrastructure에 유지합니다.
구체적인 Infrastructure 구현 대신 추상화에 의존합니다.
MCP 도구는 얇게 유지합니다.
환경별 구성을 하드코딩하지 마세요.
시크릿을 커밋하지 마세요.
타입이 명시된 Python을 선호합니다.
시스템 경계에서 외부 데이터를 검증합니다.
외부 API DTO는 Domain 모델과 구조가 다를 경우 분리하여 유지합니다.
유스케이스는 독립적으로 테스트할 수 있게 만듭니다.
숨겨진 전역 상태보다 명시적 의존성을 선호합니다.
실제 아키텍처 문제를 해결할 때 추상화를 추가합니다.
Domain은 FastMCP와 독립적으로 유지합니다.
Infrastructure 실패는 해당 경계 밖으로 노출하기 전에 변환합니다.
안정적인 구조화된 오류 코드를 사용합니다.
MCP App UI는 프레젠테이션과 상호작용에 집중하도록 유지합니다.
MCP 데코레이터 안에 비즈니스 로직을 넣지 마세요.
외부 API는 교체 가능하도록 유지합니다.
템플릿은 점진적으로 구축되고 있습니다.
FastMCP Server
|
v
HTTP Transport
|
v
Environment Configuration
|
v
Python Package Structure
|
v
Pydantic Models
|
v
Domain Entities
|
v
Repository Contracts
|
v
Error Hierarchy
|
v
Infrastructure / External API
|
v
Application Use Cases
|
v
MCP Tools
|
v
Dependency Composition
|
v
Centralized Error Handling
|
v
MCP Resources
|
v
MCP Prompts
|
v
MCP App UI
|
v
Interactive MCP Actions
|
v
Unit Tests
|
v
Integration Tests
|
v
Claude / Copilot integration최종 프로젝트는 전체 흐름을 보여주어야 합니다:
Claude / Copilot
|
| MCP over HTTP
v
FastMCP Server
|
v
MCP App UI
|
| user action
v
MCP Tool
|
v
Application Use Case
|
v
Domain Contract
|
v
Infrastructure Adapter
|
| HTTP
v
External Service오류는 반대 방향으로 안전하게 흐릅니다:
External failure
|
v
Infrastructure Error
|
v
Application / Domain Error
|
v
Presentation Error Boundary
|
v
Structured MCP Error
|
v
Claude / Copilot이 저장소는 재사용 가능한 클린 아키텍처를 사용하여 프로덕션 품질의 FastMCP 서버와 MCP 앱을 만들기 위한 템플릿 및 학습 참고 자료가 되는 것을 목표로 합니다.
이 프로젝트는 MCP 관련 관심사를 코드베이스 전체에 퍼뜨리는 대신, MCP를 애플리케이션 경계로 취급할 수 있는 방법을 보여줍니다.
핵심 비즈니스 로직은 다음으로부터 독립적으로 유지되어야 합니다:
FastMCP
MCP transport
MCP App UI
Claude
Copilot
HTTP providers
databases
external APIs이를 통해 애플리케이션을 더 쉽게:
maintain
test
extend
replace integrations
run in different environments
connect to different MCP hosts명확한 아키텍처 경계를 유지하면서.
This server cannot be installed
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
FastMCP commerce server starter: product catalog, search, and checkout. Deploy to Vercel in 5 min.
Hosted Amazon Seller and Vendor MCP server for Claude, ChatGPT, Cursor, Codex, Gemini, Copilot.
MCP Server for Slima - AI Writing IDE for Novel Authors with AI Beta Reader.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/renaisanci/mcp-clean-architecture'
If you have feedback or need assistance with the MCP directory API, please join our Discord server