nomad-marketplace
Click on "Deploy 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., "@nomad-marketplacefind web development projects between $500 and $2000"
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.
NOMAD IA — MCP Marketplace Integration Proof
A small, production-oriented proof showing how I build Model Context Protocol (MCP) + marketplace API integrations in TypeScript.
What this demonstrates
Current MCP TypeScript v2 server package (@modelcontextprotocol/server)
MCP tools for project search, project lookup and category discovery
Read-only bid-intent stub with no marketplace side effect
Typed API adapter with normalization for common project payload shapes
Request timeout and explicit upstream error handling
Optional bearer-token support without hard-coded credentials
Node.js stdio entry point
Web-standard Streamable HTTP adapter suitable for Cloudflare Workers
Automated tests using deterministic local fixtures
No secrets, customer data, fake metrics or hidden dependencies
Related MCP server: EuroVDC MCP Server
Tools
Tool | Purpose |
search_projects | Search by text, category and budget range |
get_project | Fetch one project by ID |
list_categories | List categories with a safe fallback |
submit_bid_intent | Draft-only stub; never submits in this proof |
Run locally
npm ci
npm test
npm run buildSet:
MARKETPLACE_API_BASE_URL=https://example.com/api
MARKETPLACE_API_KEY=optionalThen:
npm startClaude Desktop-style command
After building, configure a local MCP server with:
{
"mcpServers": {
"nomad-marketplace": {
"command": "node",
"args": ["/absolute/path/dist/src/stdio.js"],
"env": {
"MARKETPLACE_API_BASE_URL": "https://example.com/api"
}
}
}
}Cloudflare-compatible shape
src/worker.ts uses the MCP v2 Web Standards Streamable HTTP transport and exposes a stateless /mcp handler. Platform-specific deployment configuration is intentionally kept separate from core business logic.
Evidence
Acceptance baseline:
TypeScript compiles in strict mode.
Tests cover normalization, filters, auth-header behavior, category fallback and upstream failure handling.
Secrets are injected through environment variables only.
Bid intent remains read-only.
Node and Web-standard transports share the same MCP tool implementation.
Design choice
The API adapter is isolated from the MCP layer so a real marketplace schema can be mapped without rewriting tool behavior. That keeps delivery fast while making API-specific assumptions easy to test.
— NOMAD IA
Available Tools
4 toolsget_projectGet projectB
Return one project by marketplace project id.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden, yet it only implies a read. It omits what happens when the id is not found, whether authentication/scoping applies, and any rate or visibility constraints. 'Return one project' is a thin behavioral signal.
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 ten-word sentence with zero padding, front-loading the action and the lookup key. Nothing is wasted.
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 one-parameter read lookup with no output schema and no annotations, the description covers what it returns and the key used, which is the minimum viable. It does not address error behavior or result shape, leaving modest gaps for an agent.
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 0%, so the description must compensate for the undocumented 'id' parameter. It does clarify that the id is a 'marketplace project id', which adds useful disambiguation, but it adds no format, example, or constraints beyond that.
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?
Specifies a clear verb (return/get), the resource (one project), and the retrieval key (marketplace project id). It distinguishes itself from search_projects in spirit by emphasizing 'one project', though it never names or contrasts with that sibling 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?
No guidance on when to use this versus search_projects or list_categories. The only hint is the sibling name 'search_projects', and the agent must infer that a single-item lookup by id is the distinguishing condition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesList categoriesB
Return available project categories.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden, yet it only implies a safe read via the word 'Return'. It says nothing about whether categories are static/enumerated, their ordering, caching, or auth requirements.
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 front-loaded sentence with zero filler. For a no-argument read tool, this is the right size and nothing is wasted.
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 tool is simple (0 params, no nested objects) and there is no output schema, so the description should at least hint at what a 'category' looks like or how the list is scoped. It is minimally sufficient but thin for the only source of information about this call.
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 tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter-related gaps exist.
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?
States a specific verb (Return) and resource (project categories), which is unambiguous and clearly distinct from the sibling tools (search_projects, get_project, submit_bid_intent). It lacks any sibling cross-reference, but none is really needed given how different the resource is.
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?
There is no when-to-use guidance, no statement of prerequisites, and no mention of alternatives or when this lookup is appropriate. The agent must infer the trigger condition entirely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_projectsSearch marketplace projectsB
Search public project listings by text, category and budget range.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| category | No | ||
| budget_max | No | ||
| budget_min | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It discloses only the 'public' scope; it says nothing about result limits, pagination, ordering, or what happens when no filters are supplied (zero required params), all of which matter for a search 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?
A single front-loaded sentence with no wasted words. It is terse to the point of omitting useful detail, but nothing in it is redundant.
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 four-parameter search, the inputs and scope are adequately conveyed. However, with no annotations and no output schema, the description should have said at least what the results look like and default behavior with zero arguments; those gaps leave it only 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 description coverage is 0%, so the description must compensate, and it maps all four parameters: 'text' to query, 'category' to category, and 'budget range' to budget_min/budget_max. It lacks format details such as currency and whether budget bounds are inclusive, but the field mapping is complete.
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 names a specific verb (search) and resource (public project listings) plus the three filtering axes. It clearly distinguishes itself from get_project and list_categories, though it never explicitly references those siblings.
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?
There is no when-to-use guidance, no exclusions, and no mention of alternatives like get_project for fetching a single listing's detail. Only the implicit context that this is a discovery/browse operation hints at usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
submit_bid_intentPrepare bid intentC
Read-only v1 stub. Prepares a bid intent without submitting or changing marketplace state.
| Name | Required | Description | Default |
|---|---|---|---|
| note | Yes | ||
| amount | Yes | ||
| project_id | Yes |
TDQS
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 disclose two meaningful traits: this is a stub and it does not submit or change marketplace state, which reassures the agent about side effects. However, it says nothing about what the call returns, whether the 'bid intent' is persisted, or whether authentication/authorization is required for a bid-related 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 short sentences, front-loaded with the read-only/stub qualifier and no filler. It is efficiently sized for what it says, though the brevity leaves required information unstated rather than being genuinely complete.
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?
There are no annotations, no output schema, and no parameter documentation, so the description is the only source of behavioral information — and it omits return shape, persistence semantics, and auth requirements. For a mutation-adjacent, three-required-parameter tool, this leaves substantial gaps an agent would need to resolve.
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% and all three parameters (project_id, amount, note) are required, yet the description adds no meaning for any of them. Field names are partly self-descriptive, but there is no explanation of the amount's units/currency, the note's purpose, or how project_id relates to the sibling project tools. With low coverage the description should compensate and does not.
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 names a specific verb and resource ('Prepares a bid intent') and clarifies it is a read-only v1 stub that neither submits nor mutates marketplace state. That distinguishes it from the read-oriented siblings (search_projects, get_project, list_categories), though it never explicitly routes the agent relative to them. The verb 'prepares' remains somewhat abstract about what is actually produced.
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?
There is no statement of when to use this tool versus the sibling read tools, no preconditions, and no exclusions. The only implicit guidance is the 'read-only v1 stub' framing, which hints at limited scope but does not tell the agent when this call is appropriate. Effectively no usage guidance.
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.
4 tool updates
v1.0.0- First observed
get_project - First observed
list_categories - First observed
search_projects - First observed
submit_bid_intent
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: search_projects searches, get_project retrieves by id, list_categories lists categories, and submit_bid_intent prepares a bid. There is no meaningful overlap between any pair.
All tool names follow a consistent snake_case verb_noun pattern: search_projects, get_project, list_categories, submit_bid_intent. No deviations or mixed conventions.
Four tools is within a reasonable range for a read-only v1 surface. However, one tool is a non-functional stub, leaving only three active tools, which is slightly thin for a marketplace.
The read-only browsing tools (search, get, categories) cover discovery, but there is no actual bid submission, project creation, or lifecycle management. The submit_bid_intent stub is a dead end for any transactional marketplace workflow.
Maintenance
Related MCP Connectors
Search Bluesky posts and feeds; read profiles, threads, and trends. STDIO or Streamable HTTP.
Remote streamable-HTTP MCP server running on a single Cloudflare Worker. Your assistant gets live Airbnb, Amazon, Booking.com, Google Flights, Maps and Reddit data, social search on X, Instagram and TikTok, the Meta Ad Library, and image/video generation without any keys. Connect your own accounts to let it send WhatsApp or Telegram messages, work an IMAP inbox, manage Meta Ads campaigns and publish to X and LinkedIn. OAuth 2.1 with PKCE; stored credentials are AES-256-GCM encrypted.
Share one project context across ChatGPT, Claude, Telegram and any MCP client.
Deploy and manage Jade Hosting projects from AI clients. Jade account and OAuth required.
Related MCP Servers
- AlicenseBqualityCmaintenanceEnables MCP clients to search and manage Freelancehunt projects, bids, profiles, reviews, messages, and workspaces, with local filtering by keywords, budget, bid count, and employer quality.31MIT

EuroVDC MCP Serverofficial
AlicenseBqualityCmaintenanceEnables browsing EuroVDC's live hosting catalog, searching domains, receiving AI server recommendations, and performing agent-assisted checkout via remote HTTP or stdio.14MIT- FlicenseNot gradedqualityBmaintenanceEnables AI agents to search a shared catalog of projects, roles, orders, participants, and mentors, create and update listings or profiles, draft proposals, and search and apply across external freelance and job platforms while keeping platform credentials local.13-
- AlicenseNot gradedqualityCmaintenanceEnables any MCP host to search open positions and fetch individual job details from oneforma.com's public API/RSS through read-only search_jobs and get_job tools, with keyword, location, remote, and date filters. Runs as a standalone stdio server that works with Cursor, Claude Desktop/Code, Codex, and comparable agents without extra infrastructure.MIT