@sedis/mcp

Official

by sedis-ab

Overview Schema Related Servers Score Discussions

TypeScript

Remote

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.1.5
Disambiguation5/5
Each tool has a distinct role with clear domain prefixes (bolagsanalys_, fastighetsbenchmark_) and specific actions (list, find, search, get). Even similar-looking tools like bolagsanalys_get_data vs bolagsanalys_search_data are differentiated by cardinality. No two tools overlap in function.
Naming Consistency5/5
Tool names follow a consistent pattern of domain prefix + verb + noun, all in snake_case. Verbs are predictable (list, find, search, get, set, clear) and match the tool's function. The naming is uniform across both domains.
Tool Count5/5
At 12 tools, the server covers two distinct data domains plus session management without redundancy. Each tool serves a clear purpose in its respective workflow, and the count feels neither bloated nor sparse.
Completeness5/5
For the read-only Bolagsanalys and Fastighetsbenchmark use cases, the tool surface covers discovery (list/find), retrieval (get/search), and session lifecycle (set/clear). The workflows are fully traceable from finding an entity to pulling the final time-series. No critical operations appear missing.
Average 4.6/5 across 12 of 12 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 31 commits in the last 12 weeks
- Last stable release on July 17, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, and the description reinforces 'Read-only' and 'never writes'. It adds valuable context: data is shared, same for every key, no tenant filter, and each row exposes sedisId, name, and sourceName. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a leading 'Read-only', a clear scope statement, field list, usage context, and example. It is slightly redundant by repeating 'read-only' at the end, but overall it is efficient and earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema and annotations, the description covers purpose, shared scope, fields, and a usage example. It is complete for a list tool with rich structured metadata, though it could have explicitly listed sibling alternatives but that is not essential.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description mentions nameContains with an example, but the schema already provides the same example ('Stockholm'), so it adds little beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists 'SHARED Sedis-owned reference zones' with a specific verb (List) and resource, and distinguishes them from private data. It also notes the fields exposed and the use case, making it unambiguous and different from sibling list tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear use case ('Use a reference zone as a market benchmark to compare against your own comparison zones and property units') and gives an example with nameContains. It does not explicitly name alternative tools, but it distinguishes shared reference data from private data, giving contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description reinforces this with 'Read-only' and 'never writes'. It adds extra context beyond annotations by explaining what the tool returns and how to interpret dataType for CompDatum values. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficient, front-loading the read-only nature and purpose, then providing a concrete usage example. Every sentence adds value, and it is well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, the description does not need to explain return values. It covers the tool's purpose, relationship to another tool, and how to interpret output data types. It is complete for an AI agent to decide when and how to use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description references nameContains and group but does not add meaning beyond the schema's parameter descriptions. It does not explain each parameter, but the schema already covers that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: discovering real-estate benchmark parameters by name fragment or group, and returning specific fields (code, name, dataType, enumValues). It distinguishes itself from siblings by explicitly linking to the consumer tool fastighetsbenchmark_get_comp_timeseries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage context: 'Use this to resolve the parameterCode you pass to fastighetsbenchmark_get_comp_timeseries'. It does not explicitly mention alternatives or when not to use, but the downstream usage is clearly stated, which is strong guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description reinforces this by stating 'Read-only' and 'never writes'. It adds valuable context beyond annotations: the response exposes `containingCompSedisIds` as an array of ids (not nested objects), enabling a reference-then-resolve workflow, and notes tenant-scoping. It also clarifies that write operations are not exposed here, which is useful behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences long, with every sentence earning its place. It leads with 'Read-only', explains the key output format, gives a concrete example, and ends with an explicit write-exclusion. No fluff or repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema, the description does not need to explain return values. It covers the essential context: tenant scoping, read-only nature, the shape of `containingCompSedisIds`, a usage pattern with another tool, and a concrete filter example. This is complete for a list operation with well-documented parameters and output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage with descriptions and examples for all four parameters (page, sort, pageSize, nameContains). The description does not add new parameter-specific semantics beyond repeating the nameContains example, which is already in the schema. It does provide context on how to use the output with another tool, but that does not directly enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists collections (Samling), names the exact resource, and distinguishes itself as read-only. It also differentiates from sibling tools by explicitly noting that creating/replacing/deleting a Samling is not exposed here, and references how the output feeds into `fastighetsbenchmark_get_comp_timeseries`.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for using the tool: it lists YOUR collections, is tenant-scoped, and is read-only. It gives a specific example (`nameContains 'Stockholm offices'`) and advises passing the resulting `containingCompSedisIds` to `get_comp_timeseries` only for needed collections to keep payloads bounded. It does not explicitly contrast with sibling list tools like `list_jamforelseobjekt`, but the scoping and read-only nature make the usage clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and openWorldHint=true, and the description reinforces 'Read-only' and 'never writes'. It adds useful context like 'Shared reference data', which explains the data's nature beyond the annotation. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with 'Read-only' and the core purpose. Every sentence adds value: purpose, workflow, and example. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema and 100% schema coverage, the description does not need to repeat return structure. It provides complete context for how the tool fits into the broader API workflow, which is sufficient for an agent to select and invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are already well-documented. The description adds value with a concrete example (nameContains 'revenue', group 'Income statement') that demonstrates how to combine parameters, elevating it above the schema baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Discover') and resource ('financial parameter'), and names the specific fields returned (code, English name, group, description). It distinguishes itself from siblings by explicitly connecting to `bolagsanalys_get_data`, making its role in the workflow unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear when-to-use guidance: 'Use this to resolve the `parameterCode` you then pass to `bolagsanalys_get_data`'. It also references `bolagsanalys_list_companies` for obtaining a `companyId`, establishing a workflow. It does not explicitly mention when not to use it, but the positive use case is strong enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint. Description reinforces read-only behavior and adds new context: 'Reference data shared across all tenants' and 'never writes or ingests.' It also explains the chaining behavior (use result in get_data). No contradiction; adds useful context beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with 'Read-only.' Each sentence earns its place: safety, purpose, flow, example, shared-data note. No wasted words or repetition of schema fields.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool with 5 optional params and an output schema, the description covers safety, search criteria, return value, and downstream usage. It is complete enough for an agent to know when and how to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds a concrete example ('nameContains 'Volvo', countryCode 'SE'') and explains that the companyId result is intended for use in bolagsanalys_get_data, providing practical usage semantics beyond the schema's per-parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description states specific action: search Sedis's catalog of listed companies by name fragment or country code, returning companyId and name. It distinguishes from sibling bolagsanalys_get_data by positioning as the first step, and mentions the next tool to use.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says this is the FIRST step of the Bolagsanalys flow and to pass the returned companyId to bolagsanalys_get_data. Clear context for when to use, though it doesn't explicitly mention alternatives like bolagsanalys_search_data or fastighetsbenchmark tools, the flow guidance is strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description's 'Read-only' and 'never writes' are not contradictory. It adds valuable behavior context beyond annotations: tenant-scoping, lean-by-default behavior, and that detail:true opts into a tenant-filtered containsPropertyUnits lineage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Four concise sentences with no filler. The first sentence front-loads purpose and read-only status, the second explains the workflow, the third clarifies parameter defaults with an example, and the fourth reinforces tenant scoping. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with 5 parameters, no required fields, and an output schema, the description covers purpose, usage flow, parameter nuances, tenant scoping, and read-only safety. Pagination is handled by schema. No significant gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 extra semantics for the 'detail' parameter by explaining the lean default and the tenant-filtered lineage, and gives a concrete example for nameContains ('Stockholm'). This goes beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description states a specific verb+resource: 'List YOUR comparison zones' and clarifies what is returned (sedisId). It distinguishes from sibling tools by noting these are 'your clones of a Sedis-owned aggregate' and positions it as the first step of a flow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear usage context: it is the 'FIRST step of the §8 A6 flow' and explicitly names the next tool to use with the returned sedisId. It distinguishes 'your' zones from 'Sedis-owned' aggregates, though it does not explicitly name when-not-to-use sibling tools like list_reference_zones.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite annotations already declaring readOnlyHint and openWorldHint, the description adds valuable behavioral context: quarter bounds are packed ids (e.g., '2025Q1') and are NOT calendar dates, every row retains companyId and parameterCode, and the tool never writes. This goes well beyond the annotations to clarify potential pitfalls.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose ('Read-only. Fetch quarterly figures for one company'). It then provides necessary details in a logical order without superfluous content. Every sentence adds value, and the length is appropriate given the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a rich output schema and full schema descriptions, the description focuses on usage context rather than return values. It covers prerequisites, optional narrowing, the packed quarter format, and the read-only nature. It is complete for the tool's complexity and offers clear guidance to an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the baseline is 3. The description adds extra meaning by explaining the packed quarter format in detail, giving a concrete example (companyId 'SE-VOLV-B', parameterCode 'REV', fromDate '2024Q1', toDate '2025Q4'), and clarifying that quarterId, fromDate, and toDate are quarters, not dates. This enhances the schema's parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches quarterly figures for one company, with optional narrowing by parameter and quarter range. It specifies the verb (fetch), resource (quarterly figures), and scope (one company), and distinguishes itself from related tools by referencing prerequisites like companyId and parameterCode sourced from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use the tool (when you have a companyId from bolagsanalys_list_companies) and explains the source of required IDs. However, it does not explicitly mention when not to use it or name alternative tools such as bolagsanalys_search_data, so it stops short of full exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the full behavioral impact: it removes the token from memory and on-disk cache, and subsequent calls will omit the header until set_session is called. This goes beyond the annotations (readOnlyHint: false) by specifying exactly what gets destroyed and the side effects, which is exactly the kind of context needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core action ('Forget the locally-cached session token'), followed by the consequence and usage guidance. Every sentence earns its place with no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, no output schema, and clear annotations, the description completely covers the essential context: what it does, what happens to the token, how it affects subsequent calls, and when to use it. An agent can confidently invoke this tool based on the description alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description does not need to explain any parameter semantics, and it doesn't. It appropriately focuses on the tool's action and consequences.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the purpose: 'Forget the locally-cached session token (removes it from memory and the on-disk cache)'. It uses a specific verb ('forget') and resource ('session token'), and makes the tool's action distinct from sibling tools like set_session.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'Use it to sign out of the current session.' It also explains the behavioral consequence ('calls send no X-Api-Session header until you set_session again'), giving clear context. However, it does not explicitly mention when not to use it or contrast with alternatives beyond the implied set_session.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Although `readOnlyHint` is already true, the description adds the explicit 'read-only — never writes' guarantee, the 50-company cap with rejection behavior, the packed quarter format (not calendar dates), and the fact that rows retain `companyId` and `parameterCode`. These exceed what annotations provide and are not contradictory.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but entirely purposeful. Each sentence contributes a distinct piece of guidance (read-only, batch scope, alternatives, quarter format, cap, return envelope). It is front-loaded with the most important facts and contains no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (10 params, batch semantics), the description covers all high-stakes points: subset vs all, quarter encoding, cap, and response envelope. The presence of an output schema eliminates the need to document return fields, and the description leverages the sibling reference to complete the context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (baseline 3). The description adds valuable semantics beyond the schema: explains packed quarter format for `quarterId`/`fromDate`/`toDate`, clarifies the 50-item limit on `companyIds`, and references the return envelope of the sibling tool. This is more than just repeating schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Fetch quarterly figures'), the specific resource ('a SPECIFIC SET of companies in one call'), and the mechanism (`companyIds`). It directly distinguishes from the sibling `bolagasanalys_get_data` by contrasting the batch purpose with the all-companies alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says when to use this tool ('a specific N-company subset') and when not ('to fetch ALL companies instead omit companyId on bolagasanalys_get_data'). It also provides format conventions for quarter bounds, which is essential for correct usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint and openWorldHint annotations, the description adds critical behavior: tenant scoping ('Tenant-scoped to your data'), explicit read-only assurance ('never writes'), and default geometry omission. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence carries operational value: purpose, workflow, defaults, example, and scoping. It is front-loaded with the most critical info and avoids filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and 10 optional parameters, the description covers purpose, usage flow, parameter semantics via example, default behavior, and tenant scoping. It provides everything an agent needs to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all parameters with descriptions (100%), so baseline is 3. The description adds value with a concrete example ('propertyType 1 (Office), belongsToJamforelseobjektSedisId 'JO-A'') and clarifies the relationship between propertyType and propertyTypeName, as well as the role of belongsToJamforelseobjektSedisId in the flow.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Find') and resource ('your property units') with specific filter dimensions (name, property-type id, municipality, comparison-zone membership). It distinguishes itself from siblings by positioning as the 'object-finding step' in the §8 A6 flow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly describes the full workflow: take a comparison zone from fastighetsbenchmark_list_jamforelseobjekt, filter with belongsToJamforelseobjektSedisId, and pass sedisIds to fastighetsbenchmark_get_comp_timeseries. Also notes the lean default and includeGeometry toggle.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses important behavioral traits beyond the sparse annotations: the token is cached locally (owner-only file), sent as the X-Api-Session header on every subsequent call, and never logged or echoed. This provides critical context about statefulness and privacy.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences, each earning its place: the first states the core action and benefit, the second gives the trigger and workflow, the third explains side effects. Front-loaded and free of redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter setter with no output schema, the description fully covers the trigger condition, the exact steps to obtain the token, what the tool does with it, and post-call behavior. Nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the parameter description already includes the example prefix and workflow. The tool description reinforces these but also adds behavioral context about caching and header usage, enriching the parameter's purpose beyond the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: pasting a session token to refresh the session without restarting. It distinguishes itself from the sibling 'clear_session' by being the setter counterpart, and the title adds the specific context of 'after re-proving 2FA'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs when to use: when a tool returns 'Session re-verification required'. Provides a concrete step-by-step workflow (open reproveUrl, complete 2FA, copy token, call this tool, retry original call), eliminating ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description adds key behavioral details: rows are self-describing via dataType, enum values resolve to { value, name, enumType } (use enum.name), every row keeps its sedisId, and count:false enables cheap bulk paging. It also confirms the tool never writes, reinforcing the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficient yet comprehensive. It front-loads the read-only nature and purpose, then systematically covers inputs, data handling, pagination, and scope. Every sentence adds unique value, and the example reinforces understanding without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple parameters, enum handling, pagination) and the presence of an output schema, the description covers all essential aspects: how to interpret returned data (dataType, enum, sedisId preservation), performance tips, and tenant scoping. It leaves no critical gaps for an agent to resolve.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although schema coverage is 100%, the description adds substantial meaning: it explains where to get sedisIdIn values (from sibling tools), that parameterCode comes from fastighetsbenchmark_find_parameter and is optional, and clarifies count:false for high-volume paging. The example ties all parameters together.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Pull') and names the resource ('CompDatum time-series') while explaining it is the final step of the §8 A6 flow. It clearly distinguishes from sibling tools by specifying where to get the needed inputs (search_property_units, list_samlingar, etc.).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool (final step of the flow), what inputs to pass (sedisIdIn, parameterCode, date range), and references alternative tools for finding those inputs. It also includes a concrete example and warns against conflating Comps, providing clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![sedis-mcp MCP server](https://glama.ai/mcp/servers/sedis-ab/sedis-mcp/badges/card.svg)](https://glama.ai/mcp/servers/sedis-ab/sedis-mcp)

Score Badge

Copy to your README.md:

[![sedis-mcp MCP server](https://glama.ai/mcp/servers/sedis-ab/sedis-mcp/badges/score.svg)](https://glama.ai/mcp/servers/sedis-ab/sedis-mcp)

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/sedis-ab/sedis-mcp'

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