Nomic Atlas MCP by usefulapi

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds genuine context by naming the payload contents (schema, size, indices, projections) and the backing Atlas endpoint, but says nothing about auth requirements, failure behavior for unknown ids, 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?

Two compact sentences: the payload summary is front-loaded and the API mapping trails as a secondary detail. Every clause carries information with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description usefully enumerates what comes back (schema, size, indices, projections), which is the main gap a caller would otherwise face. It is complete enough for a single-parameter read, losing only edge-case behavior for invalid ids.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so dataset_id (a UUID) is already fully documented in the schema. The description adds nothing about the id's format or source beyond what the schema states; baseline 3 applies when the schema does the heavy lifting.

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?

Specific verb+resource ('Fetch a dataset... by id') plus a useful terminology bridge ('Atlas calls it a project') that maps the user-facing concept to the underlying API noun. The 'by id' qualifier implicitly separates it from nomic_get_dataset_by_slug, though it never names that sibling, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent can infer 'use this when you have a dataset id'. There is no explicit when-to-use statement and no routing to the obvious alternative, nomic_get_dataset_by_slug, even though that sibling exists and is the natural wrong choice.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add context. The Atlas endpoint reference and the human-readable-slug note are minor additions; nothing is said about what the dataset payload contains or behavior when a slug is not found.

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?

One tight sentence front-loads the action and keys, followed by a short API reference. No filler, though the endpoint citation is of marginal value to an agent.

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 two-parameter read tool with a fully covered schema and a readOnly annotation, the description is nearly sufficient. It omits what the returned dataset looks like and error behavior for unknown slugs, which with no output schema leaves a small gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so both parameters are already documented. The description reinforces that the two strings form a human-readable path (org slug + dataset slug) but adds no formatting, casing, or validation detail 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?

States a specific verb (fetch) and resource (dataset) plus the exact lookup keys (organisation slug + dataset slug). It implicitly contrasts with a UUID-based lookup, which distinguishes it from the sibling get_dataset, but the sibling is never named outright.

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?

"usually easier than finding the UUID" gives a clear reason to prefer this tool over the UUID-based alternative. There are no explicit exclusions or failure conditions, but the routing signal is present.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, so the non-mutating safety profile is structured, not textual. The description adds real domain context — indexes take time and unbuilt maps cause vector search failures — but says nothing about what a status result looks like, error behavior for unknown job_ids, or whether the job record persists after completion.

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 short sentences, front-loaded with the action, then the motivation, then API mapping. The REST endpoint clause is somewhat developer-doc flavored but still compact and non-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 single-parameter read tool with no output schema, the description covers what it does, why it matters, and how it maps to the API. The only meaningful gap is that the agent gets no hint about the shape or vocabulary of the returned status.

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% for the single job_id parameter, so the schema already carries parameter documentation. The description only echoes the id inside the REST path and adds no format, source, or acquisition guidance beyond that, making the baseline 3 correct.

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 and resource: 'Fetch the status of an index-building job.' An agent can distinguish this from siblings like nomic_get_tag_status or nomic_get_dataset because the resource (index job) is explicit. It stops short of naming the sibling it is not, so it lands at 4 rather than 5.

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?

Provides a clear triggering context: use this to determine whether a map/index is ready before a vector search, since 'a vector search against an unbuilt map fails.' This tells the agent when the tool is needed, though it doesn't explicitly point to alternatives for other status-checking needs.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The readOnlyHint annotation covers the safety profile consistent with 'Fetch', and the description adds behavioral context beyond it: the response includes the organisation's datasets, and the underlying Atlas endpoint (GET /v1/organization/{slug}) is disclosed. Auth requirements, rate limits, and not-found behavior remain unstated.

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?

Front-loaded with the operation and its scope in one tight sentence, followed by a short endpoint reference. Every element is short, though the Atlas endpoint line is somewhat auxiliary rather than essential to invocation.

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 single-parameter read tool with 100% schema coverage and a readOnlyHint annotation, the description states what is fetched and what the response contains, which is sufficient without an output schema. Pagination behavior for large dataset lists and error handling for an unknown slug are the only unresolved gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the single slug parameter is fully documented in the schema, including its provenance from nomic_get_user. The description adds no format, casing, or validation detail beyond that, so the baseline of 3 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?

States a specific verb and resource (fetch an organisation by slug) and adds scope by noting the datasets it holds are included. It does not, however, differentiate itself from lookups like nomic_get_user or nomic_get_dataset, which the agent must infer.

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 gives no when-to-use guidance, no prerequisites, and no named alternative. The only routing hint (slug comes from nomic_get_user) lives in the schema, not the description, and the sibling tools are never referenced.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only declare readOnlyHint=true; the description adds genuine context by mapping the call to the underlying endpoint (GET /v1/project/projection/{projection_id}/schema) and by characterizing the payload as column metadata. It stops short of noting error behavior for an unknown projection_id, so it is not fully exhaustive.

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, with the core purpose front-loaded before the API-mapping aside. The endpoint reference is compact and plausibly useful, though it is arguably redundant overhead for an agent that only needs the tool contract.

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 one parameter, no output schema, and readOnlyHint covering safety, the description's brief characterization of the returned columns is close to sufficient. It could say slightly more about the shape of the schema payload, but nothing essential to invocation is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single parameter ('The projection's id.'), so the structured field already carries the semantics. The description adds no format or sourcing detail about projection_id beyond what the schema says, keeping it at the baseline.

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 (fetch) and resource (a projection's field schema), and immediately glosses what a schema means here: 'the columns available on its records.' None of the siblings (get_dataset, get_index_job, get_user, etc.) retrieve projection schemas, so the scope is unambiguous.

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?

'one projection' implies this is a single-resource lookup rather than a listing operation, but the description offers no explicit when-to-use guidance, no prerequisites (e.g. that the projection must exist), and names no alternative sibling. Usage is inferable but not stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnlyHint=true), but the description adds genuinely useful behavior: a still-building tag returns partial results, which tells the agent to re-check rather than trust the payload. It also maps the tool to the underlying Atlas endpoint for troubleshooting. It stops short of describing the returned status values.

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 tight sentences with the core purpose front-loaded and the partial-results caveat immediately after. The trailing Atlas endpoint reference is slightly extraneous but small and non-distracting.

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 two-parameter read tool with no output schema, the description covers the essential semantics (build-in-progress may yield partial data). It leaves what a completed status payload contains unstated, but nothing actively misleads or blocks a correct 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?

Schema description coverage is 100% and both parameters are documented there (tag_id is even sourced from nomic_list_tags). The description adds no syntax, format, or id-sourcing detail beyond the schema, so the baseline 3 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?

States a specific verb and resource: check whether a tag has finished computing membership. This is clearly distinct from siblings like nomic_list_tags (enumerate) or nomic_get_index_job (job status for a different resource), so an agent can route correctly without reading the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: checking build completion after creating or listing a tag. There is no explicit when-to-use, no mention of polling cadence, and no named alternative (e.g., nomic_list_tags) for the case where the agent just wants tag metadata.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

readOnlyHint=true is consistent with 'fetch', and the description adds useful scope — the response covers the organisations the key can reach. It omits any auth/permission requirements or failure behavior, but with annotations already declaring the safe read profile the lower bar applies.

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 short sentences, front-loaded with the primary purpose, then the critical follow-on ('start here') and the API mapping. Nothing is padding; the endpoint reference is small and useful.

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 no parameters and no output schema, the description covers what the call returns (account plus accessible organisations) and how it fits the workflow. It could say slightly more about the returned fields, but it is sufficient to invoke correctly.

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; per the baseline for 0-param tools this is a 4. No parameter information is needed or missing.

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 and resource: 'Fetch the account the API key belongs to, including the organisations it can access.' It is distinguishable from the sibling nomic_get_organization because it scopes the result to the credential's own account rather than an arbitrary org.

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?

'Start here — the organisation slug feeds the other tools' gives a clear entry-point signal and explains the downstream dependency on the returned slug. It stops short of naming sibling alternatives or stating exclusions, so it is clear context rather than full when/when-not guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, so the safety profile is covered and the description's 'List' verb is consistent with it. The description adds useful semantic context (tags are human-made labelled selections) and a raw endpoint reference, but says nothing about pagination, ordering, permissions, or behavior when a projection has no tags.

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: the purpose leads, the clarifying gloss follows, and the API endpoint appears last for cross-reference. Nothing is padded and nothing important is buried.

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 low-complexity read tool with annotations covering safety and a fully documented two-parameter schema, the definition is nearly sufficient. The remaining gap is the shape of a returned tag object, which is neither in an output schema nor described here.

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% with only two trivially-described string ids, so the schema carries the full parameter burden. The description adds no format, source, or relationship details beyond what the schema already states; baseline 3 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?

Specific verb plus resource ('List the tags defined on one projection'), reinforced by a plain-language gloss that tags are 'the labelled selections a person made on the map'. It does not, however, distinguish this from the plausibly-related sibling nomic_get_tag_status, so an agent must infer the boundary from the name alone.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the narrow scope and the required dataset_id/projection_id pair, but the description gives no explicit when-to-use, no prerequisites, and no statement of when to prefer it over nomic_get_tag_status. It assumes the agent already knows it wants a projection's tag list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only declare readOnlyHint=true, so the description usefully adds the failure mode (HTTP 500 while the index is building) and confirms distances are returned alongside neighbours. That is meaningful operational context beyond the annotation, though it says nothing about pagination or limits on the number of seed ids.

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 operational facts (semantic search, built-index requirement, 500 failure, follow-up tool) are front-loaded before the endpoint string. The 'This is what Atlas is for' sentence is mildly promotional and the raw HTTP path is developer-facing noise, but the core content is tight.

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 no output schema, the description at least indicates that neighbours and distances come back, and it covers the critical prerequisite for a successful call. It does not describe result shape or ordering, so an agent still lacks full expectations for the response.

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% and each parameter is already documented in the schema (k range 1-100, datum_ids as seed records, atlas_index_id sourced from nomic_get_dataset). The description only restates that ids are seeds for the search, adding no syntax or formatting detail 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?

States a specific verb+resource: given record ids, return nearest neighbours in embedding space with distances. It also distinguishes this lookup-by-id operation from the other nomic_* siblings, which are all getters for dataset/index/job metadata, and even names the underlying endpoint.

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?

Gives a clear precondition (a BUILT index is required) and routes the agent to nomic_get_index_job when the map is still building, which prevents a predictable 500. It stops short of naming alternate search tools or explicitly stating when not to use this one, so it is strong but not exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.