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., "@mcp-camptocamp search for climbing routes in Chamonix"
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.
Serveur MCP (Model Context Protocol) exposant l'API Camptocamp.org aux LLMs. Permet d'interroger des données fiables et à jour sur les itinéraires alpins, les altitudes de sommets et les descriptions de courses — en évitant les hallucinations sur les données d'alpinisme.
Outil | Description |
| Recherche des itinéraires par mot-clé (retourne ID, titre, activités, altitude, cotation) |
| Détail complet d'un itinéraire par ID (description, cotations, dénivelé, matériel) |
| Recherche des points de passage par nom (sommets, refuges, bivouacs…) |
| Détail d'un point de passage par ID (altitude, coordonnées GPS, description) |
Related MCP server: Open-Meteo MCP Server
Prérequis : Node.js 18+
Claude Desktop — ajouter dans la configuration :
{
"mcpServers": {
"camptocamp": {
"command": "npx",
"args": ["-y", "@olaurendeau/mcp-camptocamp"]
}
}
}Cursor — ajouter dans ~/.cursor/mcp.json ou .cursor/mcp.json :
{
"mcpServers": {
"camptocamp": {
"command": "npx",
"args": ["-y", "@olaurendeau/mcp-camptocamp"]
}
}
}Prérequis : Docker
{
"mcpServers": {
"camptocamp": {
"command": "docker",
"args": ["run", "--rm", "-i", "ghcr.io/olaurendeau/mcp-camptocamp:latest"]
}
}
}Pour construire l'image localement :
docker compose build mcpPuis utiliser l'image locale mcp-camptocamp-mcp à la place de ghcr.io/olaurendeau/mcp-camptocamp:latest.
Prérequis : Docker et Docker Compose
Toutes les commandes npm passent par Docker via le Makefile :
make install # Installer les dépendances
make test # Lancer les tests
make lint # Vérification des types
make test-watch # Tests en mode watch
make build # Compiler TypeScript
make docker-build # Construire l'image de production
make help # Liste toutes les commandesLa publication est automatisée via GitHub Actions à chaque tag v* (ex. v1.0.1).
Étape 1 — Publier une première fois manuellement (une seule fois, avec ta 2FA) :
make login # authentification interactive avec 2FA
make publish # ci + tests + build + npm publishLes identifiants npm sont stockés localement dans .npm/ (ignoré par git).
Étape 2 — Configurer Trusted Publishing sur npm (remplace le token CI/CD) :
Va sur npmjs.com → ton package @olaurendeau/mcp-camptocamp → Settings
Section Trusted Publisher → choisis GitHub Actions
Renseigne exactement :
Organization or user : olaurendeau
Repository : mcp-camptocamp
Workflow filename : publish.yml
(Recommandé) Dans Publishing access, active Require two-factor authentication and disallow tokens
Étape 3 — Publier via GitHub Actions :
git tag v1.0.0
git push origin v1.0.0Le workflow publie automatiquement sur npm (via OIDC, sans token), GHCR et le registre MCP officiel.
Après le premier push Docker, rendre le package GHCR public : Settings → Packages → mcp-camptocamp → Change visibility.
make publish
# Registre MCP (nécessite mcp-publisher installé sur l'hôte)
curl -L "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
./mcp-publisher login github
./mcp-publisher publishRuntime : Node.js 22 + TypeScript
MCP SDK : @modelcontextprotocol/sdk
Transport : stdio
Tests : Vitest
Docker : image multi-stage (node:22-alpine)
MIT
Get full details of a specific outing (trip report) from Camptocamp.org by its ID, including description, conditions, weather, participants, and associated routes.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Outing ID from Camptocamp |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It indicates the tool returns detailed data but does not explicitly state it is a read-only, non-destructive operation. The absence of any hint about side effects or permissions leaves some ambiguity.
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, well-structured sentence that front-loads the purpose and lists included details. Every word adds value; 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?
Given the tool has only one parameter and no output schema, the description is reasonably complete. It covers what the tool returns and how to identify the outing. It could mention the implicit read-only nature, but overall adequate.
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 coverage is 100%, so the description adds little beyond restating the parameter's purpose. The description mentions 'by its ID' but does not provide additional context like format or constraints beyond the schema's exclusiveMinimum.
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 it retrieves full details of a specific outing by ID, listing included fields like description, conditions, weather, participants, and routes. It distinguishes itself from sibling tools like get_route, get_waypoint, and search variants.
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 outing ID and want complete details. While it doesn't explicitly state when not to use or name alternatives, the sibling tool names provide differentiation. No exclusions are needed given the focused purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get full details of a specific route from Camptocamp.org by its ID, including description, ratings, elevation data, and gear requirements.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Route ID from Camptocamp |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It does not state that the tool is read-only, mention authentication needs, or disclose any side effects. This is a significant gap for a data retrieval tool.
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 concise sentence that specifies the tool's action and output. It could be slightly more structured but is efficient and front-loaded.
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?
Given the simplicity of one parameter and no output schema, the description is reasonably complete by listing key data categories. However, it could benefit from mentioning the response format or any limitations.
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 coverage is 100% with one parameter 'id' that is well-described. The description adds no additional parameter context beyond the schema, so it meets the baseline for high coverage.
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 tool retrieves full details of a specific route by ID, listing specific data fields like descriptions, ratings, and gear requirements. It distinguishes from siblings which search or get other entity types.
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?
Usage is implied by the description: use when you have a route ID and need full details. However, no explicit guidance on when not to use or alternatives like search_routes is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get full details of a specific waypoint from Camptocamp.org by its ID, including altitude, GPS coordinates, and description.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Waypoint ID from Camptocamp |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It only states that the tool returns full details and lists a few fields, but does not disclose whether the operation is read-only, has rate limits, authentication requirements, or error handling behavior. The description minimally describes output but not side effects or constraints.
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 efficiently conveys the core purpose and output details without any waste. It is front-loaded with the action 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?
Given that the tool has only one parameter and no output schema, the description adequately covers what the tool does and what it returns (altitude, GPS coordinates, description). However, the phrase 'full details' is vague and could be more precise about all possible fields (e.g., name, type). Still, it provides sufficient context for a simple retrieval tool.
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 100%, so the baseline is 3. The description adds no additional meaning beyond the schema's 'Waypoint ID from Camptocamp'; it merely says 'by its ID'. No extra context for parameter usage.
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 specifies the verb ('Get full details'), the resource ('specific waypoint from Camptocamp.org'), and the key data fields ('altitude, GPS coordinates, and description'). It distinguishes itself from sibling tools like get_outing and search_waypoints by focusing on a single waypoint by ID.
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 use when retrieving details of a known waypoint by its ID, but it lacks explicit guidance on when to use this tool versus alternatives like search_waypoints (which might be used for searching by criteria). No when-not-to-use or prerequisite information is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for mountain routes on Camptocamp.org. Returns a list of matching routes with basic info (ID, title, activities, elevation, rating).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results | |
| query | Yes | Search query for routes (e.g. 'Mont Blanc voie normale') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It discloses the output fields but lacks details on pagination, ordering, rate limits, or other behavioral traits beyond the basic search and list operation.
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 concise sentences: first states purpose, second describes output. Front-loaded and no unnecessary words.
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 search tool with no output schema and no annotations, the description provides adequate basic info but lacks details on ordering, pagination, and error handling. It is minimally complete.
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 coverage is 100%, so the description adds marginal value. It includes an example for the query parameter, but the schema already provides descriptions for both parameters.
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 it searches for mountain routes on Camptocamp.org and lists the returned fields (ID, title, activities, elevation, rating). It distinguishes from siblings like get_route (single route) and search_waypoints (different resource).
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 for searching routes but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention 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.
List outings (trip reports) published by a Camptocamp user. Returns outings with ID, title, activities, date, elevation, and rating. Use the user_id from the Camptocamp profile URL (e.g. u=430052).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results | |
| user_id | Yes | Camptocamp user ID (e.g. 430052 for username o.laurendeau) |
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 states the returned fields but does not disclose behavioral traits like pagination, ordering, rate limits, or side effects. This is adequate but not thorough.
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 two sentences, front-loaded with purpose and output details, and contains no fluff. Every sentence is essential.
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 list tool with no output schema, the description covers purpose, parameters, and return fields. However, it lacks details on pagination behavior (e.g., if limit implies cursor-based pagination) and error conditions. Some context is missing for full autonomous use.
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 coverage is 100%, and the description adds value by explaining how to derive the user_id parameter from a profile URL. The limit parameter is not elaborated beyond the schema, but the overall semantics are well-supported.
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 tool lists outings (trip reports) by a Camptocamp user, specifying the return fields. It distinguishes from sibling tools like get_outing (single outing) and search_routes (different resource).
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 explains how to obtain the user_id from the profile URL, providing clear context. However, it does not explicitly mention when not to use this tool or point to alternatives for other needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for waypoints (summits, shelters, huts, bivouacs) on Camptocamp.org. Returns a list of matching waypoints with basic info (ID, title, type, elevation).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results | |
| query | Yes | Search query for waypoints (e.g. 'Mont Blanc', 'refuge Goûter') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It states returns basic info (ID, title, type, elevation) but does not disclose search behavior (e.g., case sensitivity, partial matching, ordering, pagination). Not misleading but could be more transparent.
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?
Single sentence, front-loaded with purpose, no unnecessary words. Efficient and to the point.
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 search tool with 2 parameters and no output schema, the description covers what it returns and gives examples. However, it omits mentioning the limit parameter (though schema covers it) and any ordering or result behavior. Still fairly complete given the tool's simplicity.
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 coverage is 100% with parameter descriptions already provided. The description adds example queries ('Mont Blanc', 'refuge Goûter') which is helpful but does not significantly enhance understanding beyond the schema.
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?
Description clearly states it searches for waypoints (summits, shelters, huts, bivouacs) on Camptocamp.org and returns matching results with basic info. It uses specific verb 'search' and resource 'waypoints', distinguishing from sibling tools like get_waypoint (retrieves single waypoint).
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?
No explicit guidance on when to use this tool vs alternatives (e.g., get_waypoint for exact ID search). The purpose is clear, but the description does not provide context for selection among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0get_outingget_routeget_waypointsearch_routessearch_user_outingssearch_waypointsEach tool targets a distinct entity (outing, route, waypoint) and action (get by ID, search). There is no overlap, and descriptions clearly differentiate them.
All tools follow a consistent verb_noun pattern: 'get_' for retrieval and 'search_' for listing. Noun forms are plural for generic searches and 'user_outings' is a clear compound noun.
With 6 tools covering the three core entities (outing, route, waypoint) with retrieval and search, the count is well-scoped and appropriate for the server's purpose.
The server lacks a general search for outings, only allowing search by user. This is a notable gap for a trip report platform where browsing all outings is essential.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Gateway between LLM agents and world data through eight tools and a bundled endpoint catalog.
Provide detailed Pokémon data and information through a standardized MCP interface. Enable LLMs an…
Curated knowledge API for AI agents - skill packs, semantic search, validated patterns.
Turn any task into the right API calls: discover, evaluate, and integrate public APIs.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/olaurendeau/mcp-camptocamp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
