What can you do with this server?

This server provides IDE-level intelligence for FastAPI projects, enabling semantic code navigation, safe refactoring, route inspection, dependency analysis, and Pydantic model introspection — backed by Jedi and Python's AST. * find_references — Locate all usages of a symbol (function, class, variable) across the project. * rename_symbol — Safely rename a symbol across all files, preventing broken references. * go_to_definition — Jump to where a symbol is defined. * get_completions — Retrieve auto-complete suggestions at a cursor position (e.g., after .). * list_routes — Enumerate all FastAPI routes in a file, including APIRouter-registered ones, with HTTP methods and paths. * get_dependencies — Retrieve the full Depends() injection tree for a route handler, including nested dependencies. * build_dependency_graph — Visualize the broader dependency graph across handlers. * list_models — List all Pydantic BaseModel classes defined in a file. * inspect_model — Deeply inspect a model's fields, types, defaults, and validators. * find_model_usages — Discover every place a Pydantic model is used as a type annotation across the project. * validate_response_models / detect_schema_orm_mismatches — Validate response models and detect mismatches between schemas and ORM models.

Which integrations are available for this server?

Provides tools for inspecting FastAPI routes, dependencies, and performing semantic code navigation and refactoring in FastAPI projects. Allows analyzing Pydantic models, listing models, inspecting fields and validators, and finding model usages across a FastAPI project.

FastAPI Architect MCP

by AbdessamadTzn

Overview Schema Source Related Servers Score Discussions Admin

Python

Local

fastapi-architect-mcp

An MCP server that gives Claude Code IDE-level intelligence for FastAPI projects — semantic code navigation, safe renaming, route inspection, dependency trees, and Pydantic model analysis.

Instead of Claude reading files blindly, it calls structured tools backed by Jedi (Python language server) and Python's AST.

Tools

Tool	Description
`find_references`	Find all usages of a symbol across the project
`rename_symbol`	Safely rename a symbol across all files
`go_to_definition`	Jump to where a symbol is defined
`get_completions`	Get completion suggestions at a cursor position
`list_routes`	List all FastAPI routes across the entire project
`get_dependencies`	Get the full `Depends()` injection tree for a handler
`build_dependency_graph`	Full graph: route → input models → dependencies → response model
`validate_response_models`	Detect routes missing a `response_model` declaration
`list_models`	List all Pydantic/SQLModel models in a file
`inspect_model`	Inspect a model's fields, types, defaults, and validators
`find_model_usages`	Find everywhere a model is used across the project
`detect_schema_orm_mismatches`	Detect field mismatches between ORM model and Pydantic schema

Related MCP server: PyEye Server

Installation

pip install fastapi-architect-mcp

Configuration

Option 1 — Global (available in all projects)

Add to ~/.claude/settings.json:

{
  "mcpServers": {
    "fastapi-architect": {
      "command": "fastapi-architect-mcp"
    }
  }
}

Option 2 — Per project (recommended for best results)

Create .mcp.json at your project root:

{
  "mcpServers": {
    "fastapi-architect": {
      "command": "/path/to/your/project/venv/bin/fastapi-architect-mcp"
    }
  }
}

Using your project's own venv gives Jedi access to all your project's dependencies, which enables full cross-file find_references and rename_symbol support.

Then restart Claude Code.

Usage examples

Once connected, you can ask Claude Code things like:

"List all routes in this project"
"What are the dependencies of the get_users handler?"
"Find all references to get_db across the project"
"Rename get_db to get_session everywhere"
"Inspect the UserCreate model"
"Are there any routes missing a response_model?"
"Show me the full dependency graph for the users router"
"Are there any mismatches between my User ORM model and UserPublic schema?"

Supported patterns

Dependency injection

def handler(x=Depends(func)) — standard FastAPI
def handler(*, x=Depends(func)) — keyword-only args
@router.get("/", dependencies=[Depends(func)]) — decorator-level deps
SessionDep = Annotated[Session, Depends(get_db)] — Annotated aliases (modern FastAPI)

Models

BaseModel — Pydantic
SQLModel — SQLModel
BaseSettings — Pydantic settings
RootModel — Pydantic v2
Inherited models (e.g. class UserCreate(UserBase))

Validators

@validator — Pydantic v1
@field_validator — Pydantic v2

Known limitations

find_references and rename_symbol work cross-file only when the MCP is configured to use the project's own venv (Option 2 above). With a global install, they only operate on the file where the symbol is defined.
get_dependencies supports native FastAPI Depends() only. Other DI frameworks (Dishka, dependency-injector, etc.) are not supported.
Runtime dependencies (middleware, lifespan events, startup hooks) are not visible to static analysis and won't appear in dependency trees.
get_completions is most useful at attribute access positions (e.g. after a .). On empty lines it returns all Python builtins.

Requirements

Python 3.11+
Claude Code (VS Code extension or CLI)

Author

Abdessamad Touzani

GitHub: @AbdessamadTzn
LinkedIn: abdessamadtouzani

Available Tools

9 tools

find_model_usagesC

Find all places a Pydantic model is used as a type annotation across the project.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes
`model`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so the description must disclose behavior. It states it finds usages but does not clarify scope (e.g., whole project, file types), whether it's read-only, performance implications, or side effects. The description is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no unnecessary words. It is well-structured and front-loaded with the key action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Although an output schema exists, the description lacks crucial context: parameter semantics, usage guidelines, and behavioral details. For a tool with two undocumented required parameters, the description does not provide sufficient information for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, meaning parameters have no descriptions. The tool description does not explain the 'file' or 'model' parameters (e.g., format, required vs optional, interpretation). The agent has no guidance on what values to provide.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb+resource construction: 'Find all places a Pydantic model is used as a type annotation.' It clearly identifies the tool's purpose and distinguishes it from siblings like 'find_references' (more general) and 'go_to_definition'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives like 'find_references' or 'get_dependencies'. The description does not mention limitations or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_referencesB

Find all references to the symbol at the given position across the project.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes
`line`	Yes
`column`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description does not disclose behavioral traits such as error handling, performance implications, or whether references include external files.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, front-loaded with action, no wasteful words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite an output schema existing, the description lacks context about the meaning of 'references', scope nuances, and error scenarios, leaving gaps for a 3-parameter tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but parameter names (file, line, column) are self-explanatory. However, the description adds no further meaning beyond the schema, so it partially compensates but not fully.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Find' and resource 'references' with scope 'across the project', distinguishing it from siblings like go_to_definition and find_model_usages.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like find_model_usages or go_to_definition; lacks explicit context or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_completionsC

Return completion suggestions at the given cursor position.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes
`line`	Yes
`column`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description is minimal. It does not disclose whether the operation is read-only, what happens if the file does not exist, any side effects, or error behaviors.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that is easy to parse and front-loaded. However, it is borderline too short and could include more detail without sacrificing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations, the description is too brief to be complete. It does not explain the output schema (though it exists), error handling, or any prerequisites for using the tool effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero description coverage for its parameters. The description only loosely implies that 'line' and 'column' define the cursor position but does not explain file path format or indexing conventions (e.g., 0-based vs 1-based).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns completion suggestions at a given cursor position, using a specific verb and resource. It distinguishes itself from sibling tools like find_references or go_to_definition, which serve different navigation purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidelines are provided about when to use this tool versus alternatives. The agent must infer usage from the name and description, with no explicit context or exclusion criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_dependenciesC

Get the full Depends() injection tree for a FastAPI handler.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes
`handler`	Yes

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so the description carries full burden. It states 'Get' which implies a read operation but doesn't disclose side effects, required permissions, or what 'full' entails. Minimal behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no wasted words, but it omits essential details. It is concise at the expense of completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple 2-parameter tool with no output schema, the description should clarify parameter values and expected output format. It does not explain what 'file' path refers to, 'handler' name format, or what the returned tree structure looks like.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 0% description coverage. The description does not explain the meaning of 'file' and 'handler' parameters beyond their names. With no schema descriptions, the description fails to add necessary semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get', the resource 'full Depends() injection tree', and the context 'for a FastAPI handler'. It distinguishes this tool from sibling tools like find_references or go_to_definition, which serve different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for retrieving dependency injection trees in FastAPI handlers but lacks explicit guidance on when to use this tool versus alternatives, no exclusions or prerequisites mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

go_to_definitionA

Return the file and line where the symbol at the given position is defined.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes
`line`	Yes
`column`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, but the description is straightforward and does not contradict any. However, it does not disclose any behavioral traits like performance or permissions beyond the basic operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence with no unnecessary words, effectively communicating the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

While the description covers the basic purpose, it lacks details about return format, error conditions, or limitations. The presence of an output schema mitigates some gaps, but the description alone is minimal.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description adds no additional meaning to the parameters (file, line, column) beyond their names. It does not explain indexing conventions or file types.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it returns the file and line where a symbol at a given position is defined, using specific verb and resource. It distinguishes from sibling tools like find_references and find_model_usages.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for navigating to a symbol's definition but provides no explicit guidance on when to use versus siblings like find_references or any prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

inspect_modelB

Inspect a Pydantic model: fields with types/defaults, and validators.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes
`model`	Yes

TDQS

B3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as read-only nature, side effects, authentication needs, or rate limits. The read-only behavior is implied but not stated.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that front-loads the purpose. It is concise but could be slightly more informative without losing brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and two parameters, the description should explain what the tool returns (e.g., fields, validators list) and clarify parameter meaning. It fails to do so, leaving gaps in agent understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not add any meaning beyond the bare parameter names. 'file' and 'model' are not explained (e.g., file path, model name), leaving the agent without guidance on their semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'inspect' and the resource 'Pydantic model', specifying what aspects are inspected (fields with types/defaults, and validators). It distinguishes from siblings like 'list_models' or 'find_model_usages' by focusing on internal details of a specific model.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for getting model details, but lacks explicit guidance on when to use this tool versus alternatives. No exclusions or context are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_modelsC

List all Pydantic BaseModel classes defined in a file.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full behavioral burden but only states the basic operation. It omits details such as output format, handling of non-existent files, or whether inherited classes are included.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence. While it lacks additional structure, it is front-loaded with the core action. It could be improved by briefly noting the parameter requirement.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple input (one parameter) and existence of an output schema, the description still fails to cover key context like file path conventions or what constitutes a 'Pydantic BaseModel' in the listing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% description coverage, yet the description does not add meaning to the 'file' parameter beyond its name. No information on allowed formats, paths, or extensions is provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (List), the resource (Pydantic BaseModel classes), and the scope (in a file). It effectively distinguishes from sibling tools like find_model_usages or go_to_definition.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus siblings. It does not mention alternatives or prerequisites, leaving the agent without decision support.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_routesB

List all FastAPI routes defined in a file, including those on APIRouter instances.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It only states the action without disclosing behavioral traits like whether it performs static analysis, handles syntax errors, or requires imports. For a read operation, it is insufficiently transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence without extraneous words. It front-loads the purpose, but could be slightly more structured (e.g., splitting into usage notes).

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has only one required parameter and an output schema (which presumably documents the route list format), the description covers the basic purpose. However, it lacks details on what kind of file is expected and how the output is structured, leaving some ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The parameter 'file' has no description in the schema, and the tool description adds no clarification (e.g., whether it expects a file path, module name, or source code string). With 0% schema description coverage, the description fails to compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists FastAPI routes in a file, including APIRouter instances. It uses a specific verb and resource, and distinguishes itself from siblings like 'list_models' which lists models, or 'find_references' which finds references.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., file must be a valid Python file with FastAPI app) or exclusions. With siblings like 'go_to_definition', a user might not know when to choose this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

rename_symbolC

Rename the symbol at the given position across all files in the project.

ParametersJSON Schema

Name	Required	Description	Default
`file`	Yes
`line`	Yes
`column`	Yes
`new_name`	Yes

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must convey behavioral traits. It mentions renaming across all files but omits side effects (e.g., undoability, file modifications, risk of breaking code) and does not clarify if the operation is read-only or write.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single short sentence, which is concise but lacks important details. It is front-loaded with the verb, but brevity comes at the cost of completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 4 required parameters with no explanations, no output schema, and no annotations, the description is insufficient. It does not cover return values, error cases, or success feedback, making it incomplete for an agent to use reliably.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description provides no additional context for parameters (e.g., file path format, line/column indexing base). Although parameter names are self-explanatory, the tool's description adds no value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (rename), the resource (symbol at given position), and the scope (across all files). It is easily distinguishable from sibling tools which focus on finding references or completions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like find_references or go_to_definition. Does not specify prerequisites, such as the symbol needing to exist or write permissions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

9 tool updatesv0.1.0May 12, 2026
- First observedfind_model_usages
- First observedfind_references
- First observedget_completions
- First observedget_dependencies
- First observedgo_to_definition
- First observedinspect_model
- First observedlist_models
- First observedlist_routes
- First observedrename_symbol

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0

Scored 2026-05-12 18:05 across 9 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: find_model_usages focuses on model-specific usage, find_references on general symbol references, get_completions on autocomplete, get_dependencies on dependency injection, etc. No two tools overlap in functionality.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case (e.g., find_model_usages, list_routes, rename_symbol), making them predictable and easy to understand.

Tool Count5/5

9 tools is well-scoped for a FastAPI development assistant, covering navigation, autocomplete, model inspection, route listing, dependency analysis, and renaming without being too few or too many.

Completeness4/5

The set covers essential code understanding tasks (navigation, model/route inspection, dependency analysis) and refactoring (rename). Minor gaps like code generation or linting are outside the apparent scope, so it's nearly complete.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Remote Desktop CommanderOAuth
app.desktopcommander
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
Shell Access OS Automation
219
mcp
dev.augments
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
Developer Tools Documentation Access
2128
nyc-property-intel
io.github.ccedacero
MCP server giving Claude AI access to 22+ NYC public-record databases for real estate due diligence
Real Estate Government Data
27
gread A
io.github.NitroRCr
An MCP server that gives your AI access to the source code and docs of all public github repos
Version Control Code Analysis Documentation Access
5361

Related MCP Servers

code-context
RAG Systems Code Analysis
nachogeinfor-ops
A
license
A
quality
C
maintenance
An MCP server that provides dynamic codebase context to Claude Code through tools like hybrid search, recent changes, and symbol definitions, enhancing AI-assisted coding with local RAG.
Updated 4 months ago (2026-05-20 12:09 UTC)
8
MIT
PyEye Server
Code Analysis Developer Tools
okeefeco
A
license
A
quality
A
maintenance
An extensible MCP server that provides intelligent Python code analysis, navigation, and understanding capabilities for AI assistants like Claude.
Updated 8 days ago (2026-09-01 20:51 UTC)
25
MIT
lovable-mcp-server
Developer Tools Code Analysis
hiromima
A
license
Not graded
quality
F
maintenance
An MCP server for real-time analysis of Lovable-generated projects, enabling Claude Desktop to instantly understand project structure, components, dependencies, and more.
Updated a year ago (2025-08-07 13:04 UTC)
39
MIT
fastapi-mcp-server
Developer Tools API Testing
vkmech999
F
license
Not graded
quality
D
maintenance
Instantly converts any running FastAPI application into an MCP server by parsing its OpenAPI spec, enabling Claude to call all endpoints via natural language without manual tool writing.
Updated 3 months ago (2026-06-12 14:22 UTC)
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AbdessamadTzn/fastapi-architect-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server