Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@rickandmorty-mcp Find Rick Sanchez's character details by ID 1"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Servidor MCP para la API pública de Rick and Morty.
Expone personajes, localizaciones y episodios como herramientas de sólo lectura,
con una capa de seguridad propia en src/rickandmorty_mcp/security/.
Gestión de paquetes: uv
SDK: mcp 2.x (MCPServer), transporte stdio
Sin claves ni secretos: la API es pública
uv sync
uv run pytest # 134 testsmacOS: los tests funcionan siempre. Si al arrancar el servidor a mano ves
ModuleNotFoundError, ejecuta./scripts/fix_venv_pth.sh. Ver Problemas conocidos.
Related MCP server: servicenow-mcp
Las tres configuraciones ya llevan la ruta absoluta de este proyecto.
El .mcp.json de la raíz ya está listo: abre Claude Code en este directorio y
aprueba el servidor cuando lo pregunte. Comprueba con /mcp.
Para tenerlo en todos tus proyectos:
claude mcp add-json rickandmorty "$(jq -c .mcpServers.rickandmorty configs/claude_code.mcp.json)" --scope useruv run python scripts/install_configs.py --claude-desktop # muestra qué haría
uv run python scripts/install_configs.py --claude-desktop --apply # lo escribe (deja .bak)O fusiona a mano el bloque mcpServers de configs/claude_desktop_config.json
en ~/Library/Application Support/Claude/claude_desktop_config.json y reinicia
la app.
Codex lee TOML (~/.codex/config.toml), no JSON. configs/codex.mcp.json es
la fuente canónica y el script hace la traducción:
uv run python scripts/install_configs.py --codex # muestra el bloque TOML
uv run python scripts/install_configs.py --codex --apply # lo añade (deja .bak)
codex mcp list # comprobarTambién puedes pegar a mano configs/codex_config.toml.
Herramienta | Para qué |
| Busca personajes por |
| Ficha de un personaje por id |
| Hasta 20 personajes por lista de ids, en una sola llamada |
| Busca localizaciones por |
| Ficha de una localización por id |
| Busca episodios por |
| Ficha de un episodio por id |
Recursos: rickandmorty://character/{id}, rickandmorty://location/{id},
rickandmorty://episode/{id}.
Todas están marcadas como read_only_hint: el servidor no escribe nada.
Las respuestas no son el JSON crudo de la API. Se proyectan a los campos
declarados en api/models.py y las URLs relacionadas se sustituyen por ids,
lo que ahorra bastantes tokens (un personaje trae hasta 51 URLs de episodio):
{
"id": 1,
"name": "Rick Sanchez",
"status": "Alive",
"species": "Human",
"gender": "Male",
"origin": { "name": "Earth (C-137)", "id": 1 },
"location": { "name": "Citadel of Ricks", "id": 3 },
"episode_ids": [1, 2, 3, "…"],
"episode_count": 51
}Los *_ids se pasan directamente a get_characters, get_episode o
get_location para profundizar.
Está aislada en src/rickandmorty_mcp/security/ — validación de entradas,
guardia anti-SSRF, rate limiting, saneamiento de salida y auditoría. El detalle
completo, con el modelo de amenazas y lo que no cubre, está en
docs/SEGURIDAD.md.
Se configura por variables de entorno con prefijo RM_MCP_ (ver
.env.example); los configs de configs/ ya traen los valores
recomendados en su bloque env.
src/rickandmorty_mcp/
├── server.py # herramientas y recursos MCP
├── api/
│ ├── client.py # cliente HTTP: timeouts, reintentos, caché, redirecciones
│ └── models.py # proyección de las respuestas
└── security/ # ← toda la seguridad, aislada
├── policy.py # límites configurables por entorno
├── validation.py # validación de entradas
├── net.py # allowlist de destino y anti-SSRF
├── ratelimit.py # token bucket
├── sanitize.py # saneamiento de salida
├── audit.py # log a stderr, con redacción
├── middleware.py # aplicación por petición
├── tooling.py # rechazos → ToolError legible
└── errors.py # tipos de error
configs/ # configuración para Claude Code, Claude Desktop y Codex
scripts/ # instalador de configs y arreglo del venv en macOS
tests/ # 134 tests
docs/SEGURIDAD.mduv run pytest -v
uv run pytest tests/test_net.py # sólo el guardia anti-SSRF
uv run python -m rickandmorty_mcp # arranca el servidor por stdioLos tests no tocan la red: respx simula la API y una fixture parchea la
resolución DNS.
macOS oculta los .pth del venv. uv escribe los archivos con un nombre
temporal que empieza por punto y luego los renombra; macOS les deja el flag
UF_HIDDEN. CPython ignora los .pth ocultos, así que la instalación
editable nunca entra en sys.path y import rickandmorty_mcp falla con
ModuleNotFoundError. El flag vuelve tras cada uv sync.
./scripts/fix_venv_pth.sh # quita el flag y comprueba el importDos partes del proyecto ya son inmunes al problema y no necesitan el script:
Los tests, porque pyproject.toml declara pythonpath = ["src"].
Los clientes MCP, porque los configs de configs/ pasan
PYTHONPATH=<proyecto>/src en su bloque env.
El script sólo hace falta para arrancar el servidor o abrir un REPL a mano.
Devuelve la ficha completa de un personaje a partir de su id numérico.
| Name | Required | Description | Default |
|---|---|---|---|
| character_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool read-only, idempotent, and non-destructive, so the description does not need to re-establish safety. It adds a small behavioral detail by promising the complete record returned for an ID, but nothing about auth, limits, or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single concise sentence that states the action and the key input with no filler. It is front-loaded with the verb and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple get-by-id operation, the description plus annotations and output schema cover what an agent needs: the tool is safe, idempotent, takes one ID, and returns the full character record. There is no missing information necessary to call it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, yet the description only restates that the input is a numeric ID, which the schema already encodes through type integer and title 'Character Id'. It does not explain where the ID comes from, its range, or any additional constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb ('Devuelve') and resource ('la ficha completa de un personaje'), and specifies the input key ('su id numérico'). The singular 'un personaje' distinguishes it from the plural/list siblings such as get_characters and list_characters.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies the tool should be used when a numeric character ID is available and a complete character record is needed. However, it does not explicitly contrast it with list_characters or get_characters, nor state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Devuelve varios personajes en una sola llamada a partir de sus ids. Útil tras una búsqueda o con los character_ids de un episodio.
| Name | Required | Description | Default |
|---|---|---|---|
| ids | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds the batch nature ('en una sola llamada') and typical id sources, but it does not disclose behavior for missing or invalid ids or ordering. This is adequate given the strong annotations, but not exceptional.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, purposeful sentences. The core action is front-loaded, and the second sentence adds practical usage context without filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple batch read with rich annotations (readOnly, idempotent, openWorld) and an output schema, the description covers the core behavior and typical use cases. Nothing an agent needs to invoke it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema only defines 'ids' as an integer array with 0% description coverage. The description clarifies that these are character ids and can come from an episode's character_ids, adding some meaning beyond the bare schema. However, it does not specify constraints like minimum/maximum count, uniqueness, or handling of duplicate ids.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'Devuelve' (returns) with the resource 'varios personajes' and the selection mechanism 'a partir de sus ids', making the core purpose clear. It distinguishes from get_character (single character) and list_characters (all characters) by emphasizing batch retrieval by ids, though it does not name sibling tools explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when the tool is useful: after a search or when working with an episode's character_ids. This gives clear context for selection, but it does not mention when not to use it or name alternatives like get_character or list_characters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Devuelve un episodio por su id, con fecha de emisión y personajes.
| Name | Required | Description | Default |
|---|---|---|---|
| episode_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful context about the return contents (air date and characters), which goes beyond what annotations provide. It does not discuss error behavior or edge cases, but given the rich annotations and simple nature of the tool, this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is concise and front-loaded with the core action. It avoids unnecessary words and clearly communicates the tool's purpose. There is no wasted content, and the key information (what it returns) is presented early.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple get-by-ID tool with one parameter, rich annotations, and an output schema, the description is adequate. It states what the tool returns (episode with air date and characters), and the output schema is presumably available for details. The lack of error handling or null-result guidance is a minor gap that is common for such tools. Overall, it is complete enough for an agent to understand the tool's function.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the burden of explaining parameters. However, the description does not mention the parameter at all. While 'episode_id' is self-explanatory, the description fails to compensate for the complete lack of schema documentation. It adds zero meaning beyond the parameter name itself.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (returns an episode), the specific resource (episode), and the key qualifier (by its id). It also lists what is returned (air date and characters), making it distinct from sibling tools like list_episodes, which would list multiple episodes. The verb+resource+scope is precise and immediately understandable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have an episode ID and need that episode's details, but it does not explicitly state when to use this tool over alternatives like list_episodes. There is no mention of when not to use it or reference to sibling tools. The guidance is implied by the phrase 'por su id' but not made explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Devuelve una localización por su id, con los ids de sus residentes.
| Name | Required | Description | Default |
|---|---|---|---|
| location_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds the useful behavioral detail that the result includes resident IDs, but it does not discuss missing IDs, errors, or response shape, which is acceptable given the annotations and output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single compact sentence with no filler. Every word contributes: it names the action, the object, the lookup key, and the returned relationship.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only getter with one required parameter, an output schema, and safety annotations, the description provides sufficient context: what to pass and what to expect. No critical operational details are missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has no parameter descriptions (0% coverage), and the description only says 'por su id,' which roughly maps to location_id without adding constraints, format, examples, or edge-case semantics. The single parameter is self-describing by name, so the minimal mapping is adequate but not rich.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with 'Devuelve una localización por su id' (Returns a location by its id), stating a specific verb and resource and clearly distinguishing this from list_locations. It also specifies the unique payload detail, 'con los ids de sus residentes,' which further identifies the tool's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for retrieving a single location by ID, and the sibling list_locations makes the alternative obvious. However, it never explicitly states when to prefer this tool over list_locations or when not to use it, leaving the routing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Busca personajes de Rick and Morty por nombre y filtros. Devuelve una página de hasta 20 resultados con el total y si hay página siguiente. El filtro name es una coincidencia parcial: 'rick' encuentra 'Rick Sanchez' y 'Evil Rick'.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| page | No | ||
| type | No | ||
| gender | No | ||
| status | No | ||
| species | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds valuable behavioral detail: it discloses page size, that the response includes total and next-page flags, and that the name filter is a partial match, which are beyond the schema and annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two succinct sentences in Spanish, front-loaded with purpose and immediately followed by operational details. No filler or repetition of schema/annotation content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description explains pagination and name matching, and an output schema exists to document return fields. But it omits explicit routing to sibling tools and valid values for the non-name filters, which are meaningful gaps for a tool with no enum constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by explaining the name filter's partial matching semantics and the meaning of the page parameter via pagination behavior. However, it does not define accepted values for type, gender, status, or species, leaving an agent to guess at valid filter strings.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Busca' = searches), resource ('personajes de Rick and Morty'), and method (by name and filters). It clearly differentiates this list/search tool from the sibling get_character/get_characters tools by describing paged results and partial name matching.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for searching and filtering characters, and mentions pagination, so an agent can infer when to use it. However, it does not explicitly name alternatives or give a when-not-to-use (e.g., 'use get_character when you have an ID'), leaving the distinction to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Busca episodios por nombre o por código de temporada/episodio. Devuelve una página de hasta 20 resultados con los ids de los personajes que aparecen.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| page | No | ||
| episode_code | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Las anotaciones ya indican operación de solo lectura, idempotente y no destructiva. La descripción añade comportamiento relevante: devuelve máximo 20 resultados por página e incluye los IDs de personajes de cada episodio. No contradice las anotaciones.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Dos frases breves en las que cada una aporta información esencial: criterios de búsqueda primero, forma de la respuesta después. Sin relleno ni repetición de información del schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Para una herramienta de listado paginado, la descripción cubre propósito, filtros, límite de página y contenido de la respuesta, y existe un output schema para los detalles de retorno. Las carencias menores son el formato exacto de episode_code y el comportamiento al no especificar filtros.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Con 0% de cobertura en el schema, la descripción compensa parcialmente: asocia 'name' con la búsqueda por nombre y 'episode_code' con el código de temporada/episodio. Sin embargo, no explica el formato del código (p. ej. S01E01) ni detalla el parámetro page más allá de la noción de paginación.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
La descripción identifica la acción (buscar), el recurso (episodios) y los criterios (nombre o código de temporada/episodio). El resultado paginado y los IDs de personajes lo diferencian claramente de get_episode, que sugiere recuperar un episodio individual.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Da contexto sobre cuándo usarlo: cuando se busca por nombre o código y se espera una lista paginada. Sin embargo, no menciona alternativas explícitas, como get_episode para un episodio concreto, ni cuándo no usar este tool; la distinción queda implícita.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Busca localizaciones por nombre, tipo o dimensión. Devuelve una página de hasta 20 resultados, cada uno con los ids de sus residentes.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| page | No | ||
| type | No | ||
| dimension | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, open-world, idempotent, non-destructive behavior. The description adds meaningful behavioral detail beyond that: it returns a page of up to 20 results and includes each location's resident IDs. This is useful operational context not present in annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: the purpose and filter criteria appear first, followed by pagination and result-shape details. Every sentence earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the essential call context: search criteria, pagination limit, and result content. Since an output schema exists, detailed return-value documentation is not required. Minor gaps remain around how filters combine and whether matching is exact or partial, but the tool is still sufficiently invokable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It successfully maps the three filter parameters (name, type, dimension) and implies the page parameter via 'Devuelve una página'. This provides meaningful semantics the bare schema lacks, although it does not detail filter combination behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Busca') and resource ('localizaciones'), and names the filtering dimensions: name, type, and dimension. It also distinguishes itself from the sibling get_location by emphasizing search/filter over direct ID lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use the tool — when searching locations by name, type, or dimension — but it does not explicitly contrast it with get_location for direct ID access or with list_characters/list_episodes for other resource types. Usage context is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a clear, distinct purpose: list_* tools search with filters, get_* tools fetch by ID, and get_characters is explicitly for bulk retrieval. The singular/plural distinction between get_character and get_characters is clarified in descriptions.
All tools follow a consistent verb_noun pattern (list_<resource>, get_<resource>) using snake_case. The naming is predictable and immediately conveys the action and target resource.
Seven tools is well-scoped for a read-only API client covering three resource types with list and get operations plus a bulk getter. Every tool serves a distinct need without redundancy.
For a read-only Rick and Morty data access server, the surface is complete: all three core resources (characters, locations, episodes) have both search and direct lookup. The bulk character fetch complements the list results and episode character ID lists.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Agent-native MCP server over the public saagarpatel.dev corpus. Read-only, stateless.
Security scanner for MCP servers. Detect vulnerabilities, prompt injection, and tool poisoning.
Twitter/X read-only MCP server — 12 tools: search, users, tweets, followers, timelines, trends.
Read-only MCP server for the OPERANT AI operating-agent calibration benchmark.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/sebastianzapatar/mcp20262'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
