All MCP tools

This catalog lists all 49 first-party MCP tools declared by the Atlan API: the session opener, search mode’s five tools, the gateway’s company-context retrieval tool, Registry tools, and tools provided by Atlan apps. Registered downstream MCP servers add an account-specific catalog described below. Always inspect the tool’s live definition before calling it: the mcp__describe_tools result in search mode, the default, or the authenticated MCP tools/list result in full mode. It is the authority for the deployment, account, exact wire name, and current input schema you are connected to.

Provider summary

Provider	Tools	Current scope
`registry`	18	Artifact discovery, reads, writes, relationships, account traces, and file uploads and reads
`agent`	6	Bulk Agent creation plus Agent, harness, and session trace reads
`skill`	5	Skill creation from inline files or uploaded bundles and Skill trace reads
`eval`	4	Run and edit scorers and read and count their stored answers
`ontology`	6	Retrieve bounded release context and governed records, export or preview interchange documents, plan SPARQL metadata queries, and retrieve logical definitions with their released physical mappings
`metric`	2	Search metric definitions and saved SQL queries in one workspace
`api`	0	No app-owned tools
`knowledge`	0	No app-owned tools
`repo`	1	Register a repository from its remote URL
`github`	0	Repository metadata synchronization; no app-owned MCP tools
`application`	0	No app-owned tools
`store`	0	No app-owned tools
`objective`	0	No app-owned tools
`billing`	0	No app-owned tools
`mcp`	7	Opens the session that later calls are recorded against, search mode’s five tools, and bounded company-context retrieval; also aggregates and routes every other tool
`otel`	0	No app-owned tools
`secret`	0	No app-owned tools
`slack`	0	No app-owned tools

Tools from ontology and metric appear only after your account installs that app with POST /registry/v1/apps/{app}/install. The gateway’s own tool is named mcp__<tool>. Registry tools are named registry__<tool>. Every other first-party tool is named extension__<provider>__<tool>.

Gateway tools

Wire name	Effect	Use
`mcp__initialise`	Write	Open an auditable MCP session.
`mcp__search_tools`	Read	Search mode: find tools for one step of a task. The first search opens the session.
`mcp__describe_tools`	Read	Search mode: get a known tool’s schema, or list a server’s tools.
`mcp__call_read_tool`	Read	Search mode: run one tool that only reads.
`mcp__call_write_tool`	Write	Search mode: run one tool that writes but is declared not destructive, or reads.
`mcp__call_tool`	Destructive write	Search mode: run any tool.
`mcp__retrieve_artifacts`	Read	Retrieve a compact, version-pinned company-context bundle: skills, metrics, ontology or Knowledge Records.

tools/list shows the session opener as mcp__initialise. Its earlier name, registry__initialise, is no longer listed, but a call to it still opens a session, so a client that saved the old name keeps working. By default, a connection to https://api.atlan.com/mcp is in search mode and lists five other gateway tools instead of this catalog: mcp__search_tools, mcp__describe_tools, and the runners mcp__call_read_tool, mcp__call_write_tool, and mcp__call_tool. They find, describe, and run the tools on this page. See Search mode tools. A connection with ?tools=full lists this catalog by name.

Registry tools

Wire name	Effect	Use
`registry__search_artifacts`	Read	Search visible artifacts by text, kind, or semantic similarity.
`registry__get_artifact`	Read	Read one artifact by handle; `include_files` adds up to 8 of its files’ text.
`registry__list_artifacts`	Read	Browse the latest artifacts of one kind.
`registry__list_workspaces`	Read	List workspaces available to the caller.
`registry__get_related_artifacts`	Read	Read typed relationships in both directions.
`registry__get_kind_schema`	Read	Read a kind’s fields and allowed relationship types.
`registry__create_artifact`	Write	Create one JSON-backed artifact.
`registry__create_artifacts`	Write	Create up to 100 JSON-backed artifacts of one kind.
`registry__patch_artifact`	Write	Change selected artifact fields.
`registry__archive_artifact`	Destructive write	Archive an artifact while retaining its content.
`registry__relate_artifact`	Write	Create or update a typed relationship.
`registry__create_artifact_linked`	Write	Create an artifact and relate it to an existing one.
`registry__list_traces`	Read	List account runs visible to the caller.
`registry__get_trace`	Read	Read one account run.
`registry__get_trace_spans`	Read	Read the spans inside one account run.
`registry__request_file_upload`	Write	Mint a short-lived upload URL and upload key.
`registry__get_file_content`	Read	Read a file artifact’s text content, up to 256 KiB.
`registry__get_file_contents`	Read	Read 1 to 8 pinned files’ text in one call, up to 512 KiB in all.

Agent tools

Wire name	Effect	Use
`extension__agent__create_bulk`	Write	Create several Agents without returning their credentials.
`extension__agent__list_traces`	Read	List runs for an Agent or coding harness.
`extension__agent__get_trace`	Read	Read one Agent or harness run.
`extension__agent__get_trace_spans`	Read	Read spans for one Agent or harness run.
`extension__agent__query_trace_stats`	Read	Aggregate Agent or harness run statistics.
`extension__agent__list_session_traces`	Read	Find traces linked to a recorded session.

Skill tools

Wire name	Effect	Use
`extension__skill__create`	Write	Create one or more Skills from inline files or an uploaded ZIP bundle.
`extension__skill__list_traces`	Read	List runs that invoked a Skill.
`extension__skill__get_trace`	Read	Read one Skill run.
`extension__skill__get_trace_spans`	Read	Read the spans inside one Skill run.
`extension__skill__query_trace_stats`	Read	Aggregate statistics over a Skill’s runs.

Eval tools

Wire name	Effect	Use
`extension__eval__score`	Write	Run a scorer over traces or sessions and store its answers.
`extension__eval__update_scorer`	Write	Edit a scorer by appending a new version.
`extension__eval__list_insights`	Read	Read stored scorer answers: one scorer’s, or an agent’s across a workspace.
`extension__eval__aggregate_insights`	Read	Count stored scorer answers instead of paging them: one card per scorer, with totals and splits by agent and scorer version.

Ontology tools

Wire name	Effect	Use
`extension__ontology__get_context`	Read	Retrieve a bounded relevant subgraph from one exact release.
`extension__ontology__get_export`	Read	Export one exact release through a versioned adapter.
`extension__ontology__get_import_preview`	Read	Parse an interchange document into a non-mutating proposal and loss report.
`extension__ontology__get_query_plan`	Read	Resolve a bounded SPARQL SELECT query into a release-pinned logical plan.
`extension__ontology__get_records`	Read	Retrieve visible records that were valid at a business-time instant.
`extension__ontology__get_binding_context`	Read	Retrieve release-pinned logical definitions, their declared physical mappings, and any missing mapping declarations.

Metric tools

Wire name	Effect	Use
`extension__metric__search_metrics`	Read	Find metric definitions in one workspace.
`extension__metric__search_queries`	Read	Find saved SQL queries in one workspace.

Repository tools

Wire name	Effect	Use
`extension__repo__register_repo`	Write	Register a repository from its remote URL and return its existing registration when repeated.

Downstream tools

Registered downstream MCP servers contribute a dynamic, account-specific catalog. Gateway advertises each tool as <server-name>__<tool-name>, where <server-name> is the server’s name folded to lowercase letters, digits, and dashes, such as linear__save_issue for a server named Linear. A server with no usable name, or one whose name another server you can see also uses, keeps remote__<server-id>__<tool-name>, where <server-id> is its mcp_server_… artifact ID. Every server’s tools also answer to that remote__ form. Copy the name from tools/list rather than constructing it. Gateway serves each downstream server’s tools from a stored catalog. tools/list returns the server’s cataloged tools, with the input schema the server listed when each tool was last cataloged, and tools/call reaches only a cataloged tool. A call to any other tool on that server fails with JSON-RPC invalid params (-32602) and data.reason set to uncatalogued. A server that has not been cataloged yet contributes no tools. A server installed from a Store definition whose release lists reviewed tools is held to them: tools/list offers only the ones the release’s review left on, and only while the server describes each exactly as reviewed — the same title, description, input schema, and behaviour hints. A call to any other tool on that server fails with the same error and data.reason set to unreviewed. A release that lists no reviewed tools leaves its server serving what it lists, and a server registered by hand serves what it lists. Gateway catalogs a server when it is registered, enabled, or pointed at a new endpoint. It refreshes the catalog hourly and when you test the server’s connection with POST /mcp/v1/servers/{server_id}/test. The hourly refresh pauses for a server that keeps failing to answer — after three days of failures, or sooner when only a configuration change can fix it — and resumes when someone who may edit the server refreshes or tests it, or its configuration changes. A server that each user signs in to with their own account is not part of the hourly refresh. A tool the server adds reaches agents after the next refresh. On a server installed from a Store definition whose release lists reviewed tools, it waits until a release that reviews it is installed: until then the gateway holds it back. A server that supports MCP Apps marks UI helper tools in each tool’s own _meta: ui.visibility names who sees the tool (model, app, or both), and ui.resourceUri names the tool’s interface. Gateway catalogues this metadata, and a tool that declares a visibility list without model is app-only: it stays out of tools/list and search results, so agents never see it. UI metadata in any other shape hides the tool too.

Provenance metadata on each tool

Gateway also writes its own _meta keys on every downstream tool, so an agent reads provenance instead of parsing the advertised name:

Key	What it holds
`com.atlan/server-id`	The server’s `mcp_server_…` artifact ID.
`com.atlan/server-name`	The server’s display name.
`com.atlan/tool`	The tool’s own name, without the namespace prefix.
`com.atlan/server-domain`	The site of the endpoint the gateway dials: its last two labels, so `acme.snowflakecomputing.com` becomes `snowflakecomputing.com`. It names the product without your organization’s own host, because a tool list reaches every caller. Absent when the endpoint is addressed by IP.
`com.atlan/server-source`	`atlan_catalog` when the server was installed from an Atlan-released definition in the Store, `custom` when someone registered it by URL.

Gateway sets these keys itself and sets or removes each one: a value the downstream server supplies in its own _meta never survives to the tool list, so a server cannot name another product. The customer’s own endpoint host, com.atlan/server-host, never appears in a tool list.

Refresh server catalog

To apply what a server lists now, call POST /mcp/v1/servers/{server_id}/refresh. Send {"is_dry_run": true} to preview the difference — no tool is written — or {} to apply it. A successful listing by a caller who may edit the server also releases a paused catalogue sync, preview or apply. The response lists the tool names in added, updated, and removed, with unchanged_count and failed_count. Applying adds new tools, updates changed ones, and archives tools the server no longer lists, so it changes which tools every agent sees and can call. Applying needs update permission on the server’s workspace. If failed_count is not 0, refresh again. A refresh returns 409 when the server is disabled, or when it lists no tools while it has a catalog: an empty listing does not replace a cataloged set. GET /mcp/v1/tools reads the stored tool records. Its first-party rows are named <provider>:<tool>, such as agent:create_bulk, not by wire name. Each row carries the tool’s catalogued argument and result schemas and its MCP Apps linkage in meta. Use authenticated protocol tools/list for the exact names an agent can call. The projection has no row for the gateway’s own tools, the session opener and mcp__retrieve_artifacts. Gateway answers both itself, so they appear in tools/list but not in GET /mcp/v1/tools or a catalog search.

Skill metadata versus tool declarations

A Skill’s allowed-tools frontmatter records dependencies. It does not register those tools with Gateway. A tool named in Skill metadata is callable only when Registry, an installed extension, or a registered downstream server advertises it.

Model access

Model Gateway serves inference over HTTP APIs and does not declare MCP tools. A model-provider connection does not add tools to the MCP catalog. See Model Gateway.

Get started

Tool references