Connect MCP servers
Proxium can hold the MCP servers of your project, such as a GitHub, Jira or docs server. Your agent connects to one URL. It gets the tools of each server, and Proxium makes the calls with the credential of the project.
| MCP URL | https://proxium.tech/mcp?project=<project> |
| Tool names | <server>__<tool>, for example github__create_issue |
| Who adds servers | The owners of the project |
| Who calls tools | The members of the project, and the virtual keys of the project |
| Credential | Sealed for the project. Nobody can read it again after you save it |
Before you start
- You are an owner of the project.
- The MCP server has an
httpsaddress on the public internet. Proxium refuses a private, loopback or link-local address. - The server signs in with no credential, with a bearer token, or with a token in a header. Sign-in with OAuth is not served yet.
1. Add a server
- In the console, open MCP servers.
- Select Add a server.
- In Name, type a short name of lower-case letters, digits and hyphens, such as
github. The nameproxiumis not allowed. - In URL, paste the MCP endpoint of the server, such as
https://mcp.example.com/mcp. - In Sign-in, select no sign-in, bearer token or token in a header. For a header, type its name in Header, such as
x-api-key. - In Credential, paste the token.
- Keep Transport at auto. Proxium tries Streamable HTTP first, then HTTP+SSE.
- Select Add and list its tools.
Proxium reads the tool list of the server. Under Tools, turn off a tool that your agents must not call, and select Save tools. If the server adds a tool later, select Refresh.
2. Connect your agent
The agent uses the URL of Connect an MCP client, with your project in it. Run proxium login and select the project. It adds the server to Claude Code and to each other tool on the machine, with the token of your login:
proxium login --project acme
The entry of Claude Code holds a headersHelper, and Claude Code runs it for the headers of each connection. The helper prints the token of proxium token, so a call reaches the server of the project with no second sign-in and no /mcp step. See Connect an MCP client for the entry that the command writes.
If you cannot run the CLI, add the server by hand and sign in with OAuth:
claude mcp add --transport http proxium "https://proxium.tech/mcp?project=acme"
Then start a new session, run /mcp, select proxium, and sign in.
The console shows this URL under Connect an agent.
| Who signs in | Tools that the agent gets |
|---|---|
| A person, with a Proxium account | The tools of Proxium, and the tools of the servers of the project |
An app, with a virtual key of the project as Authorization: Bearer mbk_… | The memory tools of Proxium, and the tools of the servers of the project. No tool of the platform and no tool of the console |
3. Read the call log
Under Tool calls, the console shows each call: when, which tool, who called it, and the outcome. Proxium does not store the arguments or the answer of a call.
Limit the tools of a key
An agent that signs in with a virtual key can call every tool of the project. To narrow it, open Keys, select Limits on the row of the key, and fill in:
| Field | Means |
|---|---|
| MCP tools | The tools that the key may call, split by commas: github__* is every tool of a server, github__create_issue is one tool. Empty: every tool |
| Tool calls per hour | The most tool calls of the key in the last hour. Empty: no ceiling |
The key then lists only its tools. A call to another tool gets 403 tool_not_allowed, and a call over the ceiling gets 429 tool_calls_capped. The server gets neither call. A person who signs in to the console is not limited by the rules of a key.
The memory tools of Proxium, such as proxium_recall_memory and proxium_record_decision, are in the same list. A key with no list gets them too, with the tools of the servers. An agent that needs the memory only takes the 21 memory tools and no tool of the platform or the console. MCP tools names them and gives the route of each one.
Set an expiry for the key of an agent. The key answers 401 after its expiry. Mint the next key before the old key expires, and remove the old one.
A member of the project can mint a key too. That key never has more tools than the member. A key minted with no list takes the member's list. A list that names a tool outside the member's list gets 403 tool_not_allowed, and no key is made. A key that an owner mints with no list has every tool.
Limit the tools of a person
An owner can also limit the tools of a member of the project. Open Team, select Tools on the row of the member, and type the tools, in the same form as for a key. The member then lists and calls only those tools, and another tool gets 403 tool_not_allowed. An owner always calls every tool. See Add your team.
Limit the tool calls of one server
A project can also set one ceiling for a whole server, shared by every caller. Open MCP, select a server, and fill in Tool calls per hour. The console sends the field max_tool_calls_per_hour.
The ceiling counts the calls to that server in the last hour, from every person and every key of the project. A call over it gets 429 tool_calls_capped, with Retry-After in seconds, and the server gets no call. Empty or 0 is no ceiling.
The ceiling of a key counts separately. A key with a ceiling of 0 still stops at the ceiling of the server.
Approve a tool before it runs
Some tools change data outside the sandbox, so a project can put them behind an approval. In the tools of a server, mark the tool with the approval checkbox. The console sends the field approval_tools.
An agent then cannot run a marked tool alone. Its first call gets 403 tool_needs_approval, and the call opens a request. The call log shows refused with the error tool_needs_approval. An owner of the project opens MCP, reads the request under Tool approvals, and selects Approve or Deny. The approval lets that caller run that tool for one hour, then the next call opens a new request.
A second call of the same tool by the same caller waits on the open request. Proxium stores no argument and no answer of a request.
| Field | Means |
|---|---|
max_tool_calls_per_hour | The most calls to the server in the last hour, from every caller. 0 is no ceiling |
approval_tools | The tools of the server that run only after an owner approves the call. This list replaces the old one |
Data protection on tool calls
The data protection of the project acts on each tool call, as on a model request:
| What Proxium does | |
|---|---|
| The arguments, before the server gets them | Each class of the project acts: flag, redact or block. A blocked call gets 403 guardrail_blocked, and the server gets no call |
| The answer, before the agent gets it | The Prompt injection class and your own terms act. With block, the agent gets a tool error that names the class. With redact, the matched text is replaced |
The text of a failed call is scanned like an answer. Base64 image and audio bytes, and the base64 blob of an embedded resource, are not scanned. They move out of the scan only in a content part of type image, audio or resource. Every key and every other string is scanned. The findings are under Data protection with the endpoint mcp, and the call log shows a blocked call as blocked. See Protect sensitive data.
Limits
| Servers in one project | 20 |
| Tools of one server | 500, and 2 MiB of tool list |
| Tool calls of one server | No ceiling by default. A project sets it, and a call over it gets 429 tool_calls_capped |
| Approval of a tool | One hour, then the caller asks again |
| Arguments of one call | 256 KiB |
| Answer of one call | 1 MiB |
| Time of one call | 60 seconds |
| Credential | 8 KiB |
API reference
The console uses these routes. Each one takes the sign-in of the console. The tool list and the call also take a virtual key of the project.
| Route | Who | Does |
|---|---|---|
GET /api/teams/{slug}/mcp/servers | Members | Lists the servers. A URL is shown without its query |
POST /api/teams/{slug}/mcp/servers | Owners | Adds a server: name, url, optional transport, auth_kind, header_name and credential |
PATCH /api/teams/{slug}/mcp/servers/{id} | Owners | Turns a server or some of its tools on or off, and sets max_tool_calls_per_hour and approval_tools |
DELETE /api/teams/{slug}/mcp/servers/{id} | Owners | Removes a server and its credential |
PUT /api/teams/{slug}/mcp/servers/{id}/credential | Owners | Replaces the credential. The answer does not hold it |
DELETE /api/teams/{slug}/mcp/servers/{id}/credential | Owners | Removes the credential |
POST /api/teams/{slug}/mcp/servers/{id}/refresh | Owners | Reads the tool list of the server again |
GET /api/teams/{slug}/mcp/tools | Members, keys | The tools that the caller may call |
POST /api/teams/{slug}/mcp/call | Members, keys | Calls one tool: name and arguments |
PUT /api/teams/{slug}/members/{email}/tools | Owners | Sets the tools of a member who is not an owner: allowed_tools (null for every tool) |
PUT /api/teams/{slug}/keys/{prefix}/tools | Members | Sets the tools of a key and its tool calls per hour: allowed_tools (null for every tool) and max_tool_calls_per_hour (0 for no ceiling) |
GET /api/teams/{slug}/mcp/calls | Members | The call log |
GET /api/teams/{slug}/mcp/approvals | Owners | The requests to run a marked tool: state is pending, approved or denied |
POST /api/teams/{slug}/mcp/approvals/{id} | Owners | Decides a pending request: decision is approve or deny |
How Proxium keeps the projects apart
- Proxium seals each credential with a key of its project. A credential copied to another project cannot be opened.
- The database shows the rows of the MCP tables only to a transaction of their project.
- Proxium checks the address of the server again at each call, and connects only to the address that it checked. It follows no redirect.
- A credential is not in an answer, in the call log or in a project export. A project export holds the URL of a server without its query.