> ## Documentation Index
> Fetch the complete documentation index at: https://proto.evodesign.org/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Server Functions

> What each function on our MCP server does

Our MCP server lets your AI assistant use Proto on your behalf. It can see your account, browse
the tool catalog, and run tools on your connected Modal workspace.

Most sessions follow the same pattern. Find a tool, look at its inputs and example, and run it. If
the tool isn't deployed to your workspace yet, your assistant can deploy it once you approve the
cost.

## Workspace

workspace\_info()

Shows which Proto account you're signed in as and what's connected to it, such as Modal and Hugging
Face. Start here if a tool won't run or a connection looks wrong.

Takes no parameters.

## Discover

list\_tools()

Lists the tools you can use. By default you only see tools that are ready to run in your workspace.
Pass `deployed_only=false` to see the whole catalog, including tools you could deploy. Each entry has
a `tool_key`, a category, a short summary, and what it needs to run.

**deployed\_only** `boolean` (default: true)

Only show tools that are ready to run. Set to `false` for the whole catalog.

**category** `string`

Only show tools in this category.

search\_tools()

Finds tools by keyword, matching against tool keys and descriptions. The best matches come first,
with the same details `list_tools` gives.

**query** `string` *required*

What to search for.

**deployed\_only** `boolean` (default: true)

Only search tools that are ready to run. Set to `false` to include tools you could deploy.

**limit** `integer` (default: 10)

The most matches to return.

## Inspect

get\_tool\_schema()

Shows what a tool takes and returns: its input, config, and output schemas. It also tells you
whether you can run the tool and whether it has an example. Check this before building an input,
because unknown or misnamed fields are rejected.

**tool\_key** `string` *required*

The tool to inspect.

get\_tool\_example()

Returns an example input that's known to work, or `null` if the tool doesn't have one. It makes a
good starting point for your own input. To run the example as is, pass `use_example=true` to
`run_tool`.

**tool\_key** `string` *required*

The tool to inspect.

get\_tool\_info()

Tells you where a tool comes from: its description, category, citation and DOI, documentation,
source code, and links to the original method. Use it when you write up results or need to cite
the tool.

**tool\_key** `string` *required*

The tool to inspect.

## Run

run\_tool()

Runs a tool and returns the result. Look at the schema first, and the example if there is one.
A run can take a few minutes when a container has to start or a model has to load.

If a run is still going after about 45 seconds, you get back `pending` and a `job_id`. The run keeps
going in the background, and `get_run_status` collects the result when it's done. If no response
comes back at all, for example because your client timed out, use `list_runs` to find the `job_id`
instead of starting the run over. Large outputs come back as stored files or download links, so
they don't fill up the conversation.

**tool\_key** `string` *required*

The tool to run.

**inputs** `object`

The tool's input. It has to match the input schema, unless `use_example` is `true`.

**config** `object`

Optional settings, matching the tool's config schema.

**use\_example** `boolean` (default: false)

Run the tool's built-in example instead of your own input.

**full\_output** `boolean` (default: false)

Return the full output, not the compact version.

## Deploy and collect

deploy\_tool()

Deploys a tool to your Modal workspace so you can run it. Deploying takes a few minutes and costs a
build on your Modal account, so your assistant should check with you first. You only need to deploy
a tool once. Deploying it again updates it to the latest version.

This call can return before the build finishes. Use `get_deploy_status` to check on it instead of
starting a second deployment.

**tool\_key** `string` *required*

The tool to deploy.

get\_deploy\_status()

Shows how a deployment started through Proto is going. You can call it as often as you like. If it
says `tracked: false`, there's no recent deployment to report on. Use `list_tools` to see whether the
tool is ready.

**tool\_key** `string` *required*

The tool to check on.

list\_runs()

Lists your recent runs, newest first, whether you started them here, on the website, or from the
SDK. Each entry has a `job_id`, `tool_key`, `status`, `created_at`, and `completed_at`. If a result
never arrived, find the run's `job_id` here and pass it to `get_run_status`. That way you don't run
it again and pay for it twice.

For runs on your own Modal workspace, the status shown is the last one we recorded. It updates when
the run is collected. Runs started with a Modal token in the request headers aren't recorded, so
they won't appear here.

**tool\_key** `string`

Only show runs of this tool.

**status** `string`

Only show runs with this status: `pending`, `running`, `completed`, `failed`, or `cancelled`.

**limit** `integer` (default: 20)

The most runs to return, up to 50.

get\_run\_status()

Collects the result of a run that came back `pending`. You can call it as often as you like while
the run is going. Each time you fetch a finished result, you get fresh download links.

**tool\_key** `string` *required*

The tool the run used.

**job\_id** `string` *required*

The `job_id` from `run_tool` or `list_runs`.

**full\_output** `boolean` (default: false)

Return the full output, not the compact version.

get\_asset()

Fetches a stored output directly, for when a download link won't open. Text comes back as text, and
other files come back as base64. Large files aren't pasted into the conversation. Use their download
links instead.

**asset\_id** `string` *required*

The stored output to fetch.

**inline\_if\_under\_bytes** `integer`

The largest file to return directly. The server caps this at 1 MB.

## Next Steps

> [card] [Connecting the MCP](https://proto.evodesign.org/docs/mcp/installation.md)
>
> Connect your AI assistant to our MCP server.

> [card] [Tools](https://proto.evodesign.org/docs/tools/introduction.md)
>
> Browse the tools available through Proto.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.