qune-tech/ocds-mcp
This server connects AI assistants to German public procurement (OCDS) data, enabling tender discovery, semantic search, and company profile-based matching with GDPR-compliant privacy.
Semantic tender search (
search_text): Natural language vector similarity search across all procurement tenders (German text works best); queries are embedded locally and matched remotely.List and filter tenders (
list_releases): Browse tenders filtered by month, CPV code, category, procurement method, value range, buyer name, NUTS region, deadline, EU funding status, award status, and more.Full tender details (
get_release): Retrieve complete OCDS release data for a specific tender by OCID, including buyer, parties, awards, and lot structure.Database statistics (
get_index_info): Check API connectivity and see counts of available releases, embeddings, and local company profiles.Company profile management: Create, update, view, list, and delete company profiles (name, description, CPV codes, categories, location) stored locally in SQLite; description changes auto-trigger re-embedding.
Tender matching (
match_tenders): Match a stored company profile against tenders using semantic KNN cosine similarity, with optional post-filtering by CPV, category, value, location, deadline, and more. Profile text stays local — only embedding vectors are sent to the API.
Works with Claude Desktop, Claude Code, Cursor, LM Studio, and other MCP-compatible AI assistants.
vergabe-mcp
Local MCP server for German public procurement search. Connects your AI assistant (Claude, GPT, etc.) to the Vergabe Dashboard API for semantic search, tender matching, and company-profile management.
Your queries and company profiles never leave your machine. They are embedded locally with a multilingual ONNX model; only the resulting embedding vectors, OCIDs, and filter values are sent to the API. Data minimisation by design.
Hosted alternative: if you just want search from your AI assistant, there is a hosted MCP connector (OAuth sign-in, no installation) — see the setup guide. This local server is for running the client in your own environment: queries and profiles are embedded locally, only vectors and filter values leave the machine, and it unlocks API-key features.
New to German public procurement? The Vergabe Dashboard knowledge base explains eForms, EU thresholds, and the tender lifecycle, and KI für Vergabe covers the hosted AI side of this server.
Quick Start
1. Get an API key
Sign up at vergabe-dashboard.qune.de and create an API key. API keys require an active Pro plan (€99/month; the local server itself is free and open source — the API gate rides key issuance).
2. Install
Via npx (easiest — downloads the correct binary automatically):
npx @qune-tech/vergabe-mcp --api-key sk_live_YOUR_KEY_HEREOr download a pre-built binary from GitHub Releases:
Platform | Download |
Linux x86_64 | |
macOS Apple Silicon | |
Windows x86_64 |
Linux / macOS:
# Example for Linux x86_64 — adjust the filename for your platform
tar xzf vergabe-mcp-linux-x86_64.tar.gz
sudo mv vergabe-mcp /usr/local/bin/vergabe-mcpWindows: Extract the zip and move vergabe-mcp.exe somewhere on your PATH.
Or build from source:
git clone https://github.com/qune-tech/vergabe-mcp.git
cd vergabe-mcp
cargo build --release
# Binary at target/release/vergabe-mcp3. Configure your AI client
Claude Desktop — edit claude_desktop_config.json:
Using npx:
{
"mcpServers": {
"vergabe": {
"command": "npx",
"args": ["-y", "@qune-tech/vergabe-mcp", "--api-key", "sk_live_YOUR_KEY_HERE"]
}
}
}Using the binary directly:
{
"mcpServers": {
"vergabe": {
"command": "vergabe-mcp",
"args": ["--api-key", "sk_live_YOUR_KEY_HERE"]
}
}
}Claude Code — add .mcp.json to your project root:
Using npx:
{
"mcpServers": {
"vergabe": {
"command": "npx",
"args": ["-y", "@qune-tech/vergabe-mcp", "--api-key", "sk_live_YOUR_KEY_HERE"]
}
}
}Using the binary directly:
{
"mcpServers": {
"vergabe": {
"command": "vergabe-mcp",
"args": ["--api-key", "sk_live_YOUR_KEY_HERE"]
}
}
}Cursor — Settings → MCP Servers → Add:
Using npx:
Command:
npxArgs:
-y @qune-tech/vergabe-mcp --api-key sk_live_YOUR_KEY_HERE
Using the binary directly:
Command:
vergabe-mcpArgs:
--api-key sk_live_YOUR_KEY_HERE
LM Studio — Settings → MCP → Add Server:
Click + Add Server and choose STDIO
Fill in:
Using npx:
Name:
vergabeCommand:
npxArguments:
-y @qune-tech/vergabe-mcp --api-key sk_live_YOUR_KEY_HERE
Using the binary directly:
Name:
vergabeCommand: full path to the binary, e.g.
/usr/local/bin/vergabe-mcpArguments:
--api-key sk_live_YOUR_KEY_HERE
Click Save
In the chat, select a model that supports tool use and enable the
vergabeserver
LM Studio requires models with tool-calling support (e.g. Qwen 2.5, Mistral, Llama 3.1+). Smaller models may not use all 11 tools reliably — 7B+ recommended.
Replace sk_live_YOUR_KEY_HERE with your actual API key. You can also pass the key via the VERGABE_API_KEY environment variable.
Related MCP server: peru-gob-mcp
Available Tools (11)
Tool | Description |
| Semantic search across all tenders (query embedded locally) |
| Filter and browse tenders by phase, CPV prefix, country, value range, deadline, buyer, procurement method |
| Raw eForms XML envelope for one OCID (optional |
| A procurement's notice lineage (PIN→CN→CAN) as |
| API health/version, embedder status, and embedding-contract check |
| Create a matching profile for your company (stored locally) |
| Update an existing profile |
| View profile details |
| List all your profiles |
| Delete a profile |
| Match a profile against all tenders by semantic similarity (vector embedded locally) |
CLI Options
Usage: vergabe-mcp [OPTIONS]
Options:
--db <DB> Local profiles database [default: profiles.db]
--data-dir <DIR> Data directory [default: data]
--api-url <URL> Vergabe Dashboard API [default: https://vergabe-dashboard.qune.de]
--api-key <KEY> API key [env: VERGABE_API_KEY]
-h, --help Print helpHow It Works
LLM ←stdio→ vergabe-mcp (local)
│ Local: company profiles (SQLite) + sentence embedder (ONNX)
│ HTTPS: vectors, OCIDs, filter values, API key
└──HTTPS──→ Vergabe Dashboard API (/api/v1)The MCP server runs locally on your machine:
Company profiles (name, description, CPV interests, location) are stored in a local SQLite database — they never leave your network.
Text embeddings are computed locally with a multilingual ONNX model (multilingual-e5-small, 384-dim). Search queries use the
query:prefix and go toPOST /api/v1/search/vector; profile descriptions use thepassage:prefix and go toPOST /api/v1/match/vector.Only embedding vectors (384 floats), the OCIDs you fetch, filter values, and your API key are sent to the API. Your query and profile text stay local.
Privacy & data flow
What stays on your machine: profile text, search-query text, CPV interests, location.
What the API sees: embedding vectors, the OCIDs you read, the filter values you use, and your API key. These reveal commercial interest (which sectors, buyers, value bands, tenders you look at) but not the underlying text. Embedding vectors are a derived, pseudonymous representation — minimisation, not elimination.
First-run model download: on first use the server downloads the embedding model from huggingface.co:
What:
model.onnx+tokenizer.json, ~118 MB total.When: the first time the embedder runs; cached afterwards at
~/.cache/vergabe/models/multilingual-e5-small.From:
huggingface.co(a US-operated third party). No user data is sent in this fetch — it is a plain model download.
For air-gapped / enterprise installs, place model.onnx and tokenizer.json in the cache directory above and the runtime download is skipped.
Requirements
An API key from vergabe-dashboard.qune.de on the Pro plan (€99/month)
~120 MB disk space for the ONNX model (downloaded automatically on first run)
Internet connection to reach the API
License
MIT — see LICENSE.
Available Tools
10 toolscreate_company_profileA
Create a company profile for tender matching. Store company name, description, CPV codes, categories, and location. The description is automatically embedded for semantic matching if the embedder is loaded. Returns the profile ID and embedding status.
| Name | Required | Description | Default |
|---|---|---|---|
| categories | No | Procurement categories of interest (e.g. ['works', 'services', 'goods']) | |
| cpv_codes | No | CPV codes the company is interested in (e.g. ['45000000', '72000000']) | |
| description | Yes | Description of the company's activities, products, and services. German text recommended for best matching quality. | |
| location | No | Company location (e.g. 'Berlin, Germany') | |
| name | Yes | Company name |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes automatic embedding behavior and return of profile ID and embedding status. No annotations provided, so description carries burden; it's informative but lacks error conditions or idempotency details.
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?
Three concise sentences, front-loaded with main action. No redundant information.
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?
Covers purpose, stored data, behavioral side effect, and return values. Lacks details on required auth or error handling, but adequate for a create 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 coverage is 100%, but description adds value: explains that description is auto-embedded and recommends German text. This goes beyond schema definitions.
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?
Clearly states the tool creates a company profile for tender matching, listing stored fields (name, description, CPV codes, categories, location) and mentioning automatic embedding. Distinguishes from sibling tools like delete, get, update, match_tenders.
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?
Implies usage for creating profiles for tender matching. Recommends German text for better quality, indicating context of use. No explicit when-not or alternatives, but purpose is self-evident.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
delete_company_profileA
Delete a company profile and its embedding by ID.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | The UUID of the company profile to delete |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It mentions embedding deletion, which is useful, but fails to disclose if deletion is irreversible, requires authorization, or returns output. The insight about embeddings adds value but 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loading the core action and specific scope in a single sentence with no extraneous 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?
For a simple delete operation with one parameter, the description is adequate but incomplete. No output schema, no annotations, and missing details about return values or error handling. It covers the basic function but not the full context.
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 the parameter 'id' already described. The description adds minimal value beyond 'by ID', aligning with the schema. Baseline score is appropriate.
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 (delete), the target resource (company profile), and the specific scope (including its embedding), distinguishing it from sibling tools like get, list, update, and create.
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 tool versus alternatives, such as prerequisites (e.g., ensuring no dependencies) or potential consequences. The description lacks context for appropriate invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_company_profileA
Get a company profile by its ID. Returns the full profile including name, description, CPV codes, categories, location, and embedding status.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | The UUID of the company profile to retrieve |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It lists return fields but does not explicitly state that the operation is read-only, require any authentication, or disclose other behavioral traits.
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 sentences with no wasted words. The first sentence states the core action, and the second lists key return fields. Front-loaded and efficient.
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 retrieval tool with one parameter and no output schema, the description is sufficiently complete, covering purpose and return content. Minor gaps include missing error scenarios or authentication needs.
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 a clear parameter description. The tool description adds no extra meaning beyond 'by its ID', maintaining a baseline of 3.
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 ('Get') and the resource ('company profile by its ID'), and distinguishes from siblings like list_company_profiles (list vs single) and create/update/delete by being a read operation.
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 retrieving a single profile by ID but offers no explicit guidance on when to use this tool versus alternatives like search_text, nor does it mention any prerequisites or limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_index_infoA
Get combined statistics: release and embedding counts from the REST API, plus local company profile counts. Call this first to check connectivity and see what data is available.
| 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 burden of behavioral disclosure. It indicates a read operation and mentions data sources (REST API, local), but does not disclose potential side effects, authentication needs, or rate limits. It is moderately 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?
The description is two sentences, front-loaded with the core purpose, and every sentence adds value. 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?
Given the context of zero parameters, no output schema, and many sibling tools, the description fully explains what the tool does and its role as an initial connectivity and data availability check. It is complete and appropriately scoped.
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 has zero parameters, so schema coverage is 100%. The description does not need to add parameter details, and it appropriately adds value by explaining what the tool returns and its purpose.
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 verb 'Get' and the resource 'combined statistics', detailing what is included: release and embedding counts plus local company profile counts. It distinguishes itself from sibling tools which are CRUD operations on specific entities.
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 explicitly advises to call this tool first to check connectivity and see available data, providing clear guidance on when to use it. While it doesn't mention when not to use it or name alternatives, the usage context is well defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_releaseA
Get the full OCDS release data for a specific tender by its OCID (Open Contracting ID). Returns the complete release JSON including tender details, buyer, parties, awards, and lot structure. Data is fetched from the REST API.
| Name | Required | Description | Default |
|---|---|---|---|
| ocid | Yes | The OCID (Open Contracting ID) of the release to retrieve |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It mentions the output includes specific fields and that data comes from a REST API, but lacks details on error handling, authentication, or rate limits.
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 concise with two sentences. The first clearly states the purpose, and the second adds useful output details. No extraneous information.
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 no output schema, the description adequately explains the return value (complete release JSON with key fields). It could mention error cases, but overall 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 coverage is 100% for the single parameter 'ocid', and its schema description adequately explains it. The tool description adds no extra semantic value 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?
The description clearly states the tool's purpose: retrieving the full OCDS release data for a specific tender by OCID. It distinguishes from sibling tools like list_releases, which likely returns multiple records.
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 is provided on when to use this tool versus alternatives. For example, it doesn't specify that users need an OCID, or contrast it with list_releases for broader queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_company_profilesA
List all company profiles. Returns a summary of each profile (without description) ordered by creation date.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses key behaviors: returns summaries without descriptions, ordered by creation date, and implies it is a read-only listing operation. However, it lacks details on pagination, authentication needs, or rate limits.
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 efficiently conveys purpose and return characteristics with no redundant 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?
Given no output schema, the description adequately explains the return value (summary, without description, ordered). However, it lacks mention of whether the result is paginated or truncated, which would be helpful for completeness.
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?
No parameters exist, so schema coverage is 100%. The description adds no parameter-specific meaning, but this is acceptable as the tool has no inputs; baseline 4 applies.
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 'List all company profiles' with a specific verb and resource, and distinguishes itself from sibling tools like get_company_profile by noting it returns only summaries without descriptions and ordered by creation date.
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 listing all profiles but provides no explicit guidance on when to use this tool over alternatives like get_company_profile or search_text, nor does it mention any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_releasesA
List and filter OCDS procurement releases by structured criteria: month, CPV code prefix, procurement category, procurement method, value range, and buyer name. Supports pagination. Data is fetched from the REST API. Use this for tender discovery before drilling into specific releases with get_release.
| Name | Required | Description | Default |
|---|---|---|---|
| buyer_name | No | Filter by buyer name (case-insensitive substring match) | |
| cpv_prefix | No | Filter by CPV code prefix (e.g. '45' for construction, '72' for IT) | |
| deadline_after | No | Only include tenders with deadline on or after this ISO-8601 datetime | |
| deadline_before | No | Only include tenders with deadline on or before this ISO-8601 datetime | |
| eu_funded | No | Filter by EU funding status (true = EU funded) | |
| has_awards | No | Filter by whether the release has awards with suppliers (true/false) | |
| limit | No | Maximum number of results (default 20, max 200) | |
| location_nuts | No | Filter by delivery location NUTS code prefix (e.g. 'DE3' for Berlin) | |
| main_procurement_category | No | Filter by main procurement category (e.g. 'works', 'goods', 'services') | |
| month | No | Filter by month in YYYY-MM format | |
| nuts_code | No | Filter by NUTS code prefix (e.g. 'DE2' for Baden-Württemberg) | |
| offset | No | Offset for pagination (default 0) | |
| procurement_method | No | Filter by procurement method (e.g. 'open', 'selective', 'limited') | |
| result_code | No | Filter by result code (e.g. 'selec-w' for selected winner, 'clos-nw' for closed no winner) | |
| status | No | Filter by tender status (e.g. 'active', 'complete', 'cancelled') | |
| submission_deadline_after | No | Only include tenders with submission deadline on or after this ISO-8601 datetime | |
| submission_deadline_before | No | Only include tenders with submission deadline on or before this ISO-8601 datetime | |
| tag | No | Filter by lifecycle tag (e.g. 'tender', 'award', 'planning') | |
| value_max | No | Maximum tender value | |
| value_min | No | Minimum tender value |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It mentions pagination and data source ('fetched from the REST API') but fails to discuss response format, defaults, error handling, rate limits, or whether the operation is read-only. Given the 20-parameter complexity, this is insufficient for an agent to safely invoke the 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 three concise sentences, each carrying essential information: purpose and filters, pagination and data source, and usage guidance. No fluff or repetition.
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?
With 20 parameters, no output schema, and no annotations, the description is too sparse. It does not clarify how filters combine (AND/OR), default sorting or ordering, response structure, or error behavior. The agent would lack critical context for correct invocation.
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%, meaning every parameter has a description in the input schema. The tool description only summarizes a subset of filters without adding new meaning, so the baseline score of 3 is appropriate.
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 verb 'List and filter' and the resource 'OCDS procurement releases', specifies several filtering criteria (month, CPV prefix, etc.), and explicitly distinguishes from the sibling tool `get_release` by stating it is for 'tender discovery before drilling into specific releases'.
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 provides explicit guidance: 'Use this for tender discovery before drilling into specific releases with get_release.' This clarifies the primary use case and indicates an alternative tool for detailed information, though it does not list when NOT to use it or mention any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
match_tendersA
Match a company profile against tenders using semantic similarity. The profile's embedding is sent to the REST API for KNN cosine search against all tender chunks. Results are enriched with release metadata from the API and can be post-filtered by CPV prefix, category, method, value range, buyer name, deadline, and status. Deduplicates by OCID (keeps highest score).
| Name | Required | Description | Default |
|---|---|---|---|
| buyer_name | No | Filter by buyer name (case-insensitive substring match) | |
| cpv_prefix | No | Filter by CPV code prefix (e.g. '45' for construction, '72' for IT) | |
| deadline_after | No | Only include tenders with deadline on or after this ISO-8601 datetime | |
| deadline_before | No | Only include tenders with deadline on or before this ISO-8601 datetime | |
| eu_funded | No | Filter by EU funding status (true = EU funded) | |
| has_awards | No | Filter by whether the release has awards with suppliers (true/false) | |
| k | No | Number of matching tenders to return (default: 10) | |
| location_nuts | No | Filter by delivery location NUTS code prefix (e.g. 'DE3' for Berlin) | |
| main_procurement_category | No | Filter by main procurement category (e.g. 'works', 'goods', 'services') | |
| procurement_method | No | Filter by procurement method (e.g. 'open', 'selective', 'limited') | |
| profile_id | Yes | The UUID of the company profile to match against tenders | |
| status | No | Filter by tender status (e.g. 'active', 'complete', 'cancelled') | |
| tag | No | Filter by lifecycle tag (e.g. 'tender', 'award', 'planning') | |
| value_max | No | Maximum tender value | |
| value_min | No | Minimum tender value |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It explains the algorithm (semantic similarity, KNN search, enrichment, dedup), but does not disclose read-only nature, auth, or rate limits. The behavior is well-described but some aspects are missing.
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?
Three sentences, front-loaded with the core action. Each sentence is informative and necessary: method, filters, dedup. 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 15 parameters and no output schema, the description explains the matching algorithm and filtering but does not describe the return format or enriched metadata contents. Still fairly complete for a complex 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 coverage is 100%, so baseline is 3. The description adds context about post-filtering but does not significantly enhance parameter meaning beyond the schema descriptions.
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 matches a company profile against tenders using semantic similarity, describes the process (embedding, KNN cosine search, enrichment, filtering, deduplication), and distinguishes itself from sibling tools like search_text and list_releases.
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 provides clear context for use (finding semantically similar tenders to a profile) and lists extensive filtering options, but does not explicitly state when not to use it or name alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_textA
Search tenders by text query. The query is embedded locally using multilingual-e5-small and matched against tender chunks via cosine similarity on the REST API. German text works best for matching German procurement data.
| Name | Required | Description | Default |
|---|---|---|---|
| k | No | Number of results to return (default: 10) | |
| query | Yes | Text query to search for (German works best). The query is embedded locally and matched against tender chunks via cosine similarity. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the embedding model ('multilingual-e5-small'), the matching method ('cosine similarity'), and language preference. However, it does not mention pagination, what happens with k=0, or output format, leaving some behavioral gaps.
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 sentences, no filler. The purpose is front-loaded, and every sentence adds value. Highly concise and well-structured.
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 low complexity with 2 params, but no output schema exists. The description does not explain the return format (e.g., list of tenders with scores), which would help completeness. Adequate but could be improved with output details.
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 descriptions for both parameters. The tool description adds context about the embedding and matching process, but this is general, not parameter-specific. For the 'k' parameter, no extra meaning is added beyond the schema's default note. Baseline 3 is appropriate.
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 verb ('Search') and resource ('tenders by text query'), and distinguishes from siblings by specifying the use of 'multilingual-e5-small' embedding and cosine similarity. This technical detail helps differentiate it from other search or match tools.
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 provides a language hint ('German text works best') but does not explicitly state when to use this tool versus alternatives like 'match_tenders'. No exclusion criteria or context for optimal use are given, so usage guidance 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.
update_company_profileA
Update a company profile. Only provided fields are changed. If the description changes, the profile is automatically re-embedded.
| Name | Required | Description | Default |
|---|---|---|---|
| categories | No | New procurement categories (replaces existing) | |
| cpv_codes | No | New CPV codes (replaces existing) | |
| description | No | New description | |
| id | Yes | The UUID of the company profile to update | |
| location | No | New location. Use empty string to clear. | |
| name | No | New company name |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses partial update behavior and that description changes trigger auto-re-embedding. However, no annotations exist, so the description carries the full burden; it lacks details on side effects, auth requirements, or idempotency.
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 sentences, no wasted words. The purpose is stated first, followed by a critical behavioral note. 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?
Adequate for basic functionality but lacks context on error handling (e.g., non-existent id), return value (no output schema), and any additional constraints. The re-embedding detail is a plus.
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%, but the description adds value by explaining partial update semantics and noting that empty string clears the location field. This goes beyond the schema's parameter descriptions.
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 'Update a company profile' with the specific verb 'update' and resource 'company profile'. It distinguishes from sibling tools like create, delete, get, list.
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 versus alternatives like create_company_profile or delete_company_profile. The phrase 'Only provided fields are changed' implies partial update but does not clarify prerequisites or scenarios.
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.
10 tool updates
v1.0.0- First observed
create_company_profile - First observed
delete_company_profile - First observed
get_company_profile - First observed
get_index_info - First observed
get_release - First observed
list_company_profiles - First observed
list_releases - First observed
match_tenders - First observed
search_text - First observed
update_company_profile
TDQS
Scored across 10 tools
Each tool has a clearly distinct purpose: CRUD for company profiles, listing/fetching releases, text search, semantic matching, and index info. No overlap in functionality.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., create_company_profile, list_releases, match_tenders). No mixing of styles.
10 tools is well-scoped for the domain of company profile management and OCDS tender matching. Each tool serves a necessary function without redundancy.
The tool set covers full CRUD for company profiles, comprehensive tender discovery (listing, filtering, text search, semantic matching), and metadata about indexes. No obvious gaps for the intended use case.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for French (BOAMP) + EU (TED) public procurement data via TenderAPI.
TED MCP Server: Real-time EU public tenders access. https://www.lexsocket.ai/
Personal knowledge base MCP server with semantic search, auto-categorization, metadata extraction
Related MCP Servers
- AlicenseAqualityDmaintenanceLocal-first RAG indexing and semantic search MCP server. Enables document retrieval and context-aware queries using local embedding models.316MIT
- FlicenseNot gradedqualityCmaintenanceMCP server for Peruvian government data, enabling search and anomaly detection in public procurement (OSCE) and legislative tracking (Congress), plus semantic search over both domains.-
- AlicenseAqualityAmaintenanceMCP server providing read access to Swiss public procurement data via the official simap.ch API, covering all cantons and the Confederation with intraday updates. It enables searching tenders, awards, construction codes, and procurement offices through natural language queries.9MIT
- AlicenseAqualityCmaintenanceMCP server that enables local hybrid semantic and keyword search over private PDF, DOCX, Markdown, and text documents without sending data to embedding APIs.93,331MIT