ramen-mcp-bridge
A stdio MCP server that forwards every JSON-RPC message to a Ramen
worker's ramen.v1.Mcp/Call over gRPC. It exists for MCP clients that can only start a local process
(stdio) — Claude Desktop, Cursor, and the reference mcp SDK all speak Streamable HTTP directly against
Ramen's edge and don't need it; see Get started
for that path instead.
Install
Bridge 1.0.0 is the bridge for Ramen 1.0.0 (policy bundle, TLS by default, local rails); see
CHANGELOG.md. Older bridges (0.3.x) cannot carry a group's policy versions, so a Ramen 1.0.0 group
with Required policies refuses their calls (-32028).
pip install ramen-mcp-bridge # → ramen-mcp-bridge on PATH
# or: uv tool install ramen-mcp-bridge
Use
TLS is the default (1.0.0, Ramen D86). The bridge always dials TLS and verifies the server against your
system's CA trust store; --tls is still accepted so older configs keep working, but it changes nothing.
Against a cloud deployment (GKE, EKS or AKS) fronted by a load balancer with a publicly-trusted certificate (the default since Ramen v0.5.5 — see deploy/README.md):
ramen-mcp-bridge --target <public-hostname>:443 --key rmk_… --group demo --zone a
Nothing to download, no kubectl command. A cluster still using the self-signed fallback needs its certificate
pulled once (kubectl -n ramen-system get secret ramen-console-tls -o jsonpath='{.data.tls\.crt}' | base64 -d > ramen-lb.pem) and --ca ramen-lb.pem. --ca replaces the system trust store for that connection (and for the
console during --oauth sign-in); the hostname is still verified.
Against a local Ramen (make up, which runs TLS with its generated CA since Ramen D86):
RAMEN_MCP_KEY="$KEY" ramen-mcp-bridge --target localhost:8080 --ca deploy/local/.certs/ca/ca.crt --group demo --zone local
--insecure (RAMEN_BRIDGE_INSECURE=1) speaks plaintext h2c and prints plaintext h2c: local development only on
stderr — for a bare ramen-node on your laptop, never for a deployment (Ramen's cloud workers refuse plaintext).
--insecure next to --tls or --ca (flag or RAMEN_BRIDGE_CA) is an error (exit 2), not a silent downgrade.
Sign in as yourself (0.2.0)
Instead of a shared rmk_ group key, the bridge can sign you in through the console — with your password, a
magic link, or the identity provider the console is configured with (Microsoft Entra ID, Google Workspace, any OIDC
issuer). A super admin registers an OAuth client on the console's Config page with the redirect URI
http://127.0.0.1/callback (any port) and gives you its client id; your account needs a role in the group (an
MCP User is enough):
ramen-mcp-bridge --target <public-hostname>:443 --oauth https://<public-hostname> --client-id <client id> \
--group demo --zone a
The first run opens your browser on the console's sign-in page (--no-browser prints the URL instead). Access
tokens are scoped to mcp:<group>:<zone>, refreshed before they expire and after the worker answers
UNAUTHENTICATED; every call the worker logs then names your account (user:<id>), not a key.
Where the tokens live (0.3.0). In the bridge's memory, nowhere else, unless you ask: --keychain keeps them in the
operating system's secret store (macOS Keychain through security, a Secret Service such as GNOME Keyring through
secret-tool), behind its own access control; --token-file <path> keeps them in a plain file with mode 0600, meant
for automation only. Thirty minutes after the last call the bridge forgets its tokens (--idle-timeout, seconds,
0 disables), and the next call needs a fresh sign-in. When a sign-in is needed while an MCP client is connected
the bridge does not block: it starts the browser flow and answers the call with error -32001 whose message carries
the sign-in link (data.sign_in_url too), so an AI client can show it to you; once you approve, the next call goes
through. Environment: RAMEN_BRIDGE_OAUTH, RAMEN_BRIDGE_CLIENT_ID, RAMEN_BRIDGE_KEYCHAIN=1,
RAMEN_BRIDGE_TOKEN_FILE, RAMEN_BRIDGE_IDLE_TIMEOUT.
Expiry mid-task is invisible and safe. When the access token runs out while a client is working, the worker
answers UNAUTHENTICATED before the call reaches any tool code; the bridge refreshes the token and repeats that one
call. A tool is never run twice by the bridge: a call that reached the runtime either returns a result or an error,
and neither is retried. The browser only reappears when the bridge has forgotten its tokens (thirty minutes idle, or
a new bridge process without --keychain/--token-file), when the refresh token itself has expired on the console
(thirty days unused), or when it was revoked because your role, password or account changed. The MCP session the client holds is bound to your
account, not to the token, so it survives the refresh.
Telemetry through Ramen (1.0.0)
A Ramen group can require telemetry about what its clients do (Ramen 1.0.0a, CONTRACTS §26.3): tool name, timing, outcome and the model's reasoning — never arguments or results. The bridge is such a client:
- At sign-in the token answer's
telemetryobject (collector endpoint, headers, configversion) is kept encrypted in the bridge's memory under a key drawn for this process; it is never written to disk (not even with--keychain/--token-file) and never logged. - Every call the bridge forwards is recorded (
kind: "mcp", the method ortools/call <tool>, duration, outcome). The bridge adds a toolramen_report(kind, name, ms, ok, reasoning)to the server'stools/list; its description tells the model to report its own model calls and non-MCP tool calls, with its reasoning (4 KiB kept), before the next Ramen call. The bridge records those locally and never forwards the call. - Every
tools/call,prompts/getandresources/readit forwards carries everything recorded since the last report underparams._meta["io.ramen/telemetry"](version,seq,events; at most 200 events / 64 KiB per report, the rest goes with the next one). The body is forwarded in the MCP era the host spoke; a host on 2025-06-18 stays legacy. -32025 telemetry config changed→ the bridge signs in again (refresh grant, else the browser flow, reported as-32001with the link while serving) and retries that one call.-32024 telemetry report requiredwhen the bridge holds no config → it signs in again; with a staticrmk_key it adopts the version the worker named. A worker's-32003 forbidden: this group requires telemetry …(what a legacy body without the report gets) is treated the same way: one re-sign-in, then the retry carries the report. The consent checkbox on the sign-in page is unchanged: declining ends the sign-in.- Started from a still-valid
--token-filethe bridge makes no token request, so it holds no telemetry object; when the bundle says the group requires telemetry it asks for the token (refresh grant) before its first gated call, so that call already carries the report.
The policy bundle and your editors (1.0.0)
A Ramen group's policy for its clients is what the token answer carries at sign-in: the telemetry object above
and, when the group repo has mcp/evals/promptfooconfig.yaml, an evals object (version, required, and the
config text) — Ramen 1.0.0c, CONTRACTS §29.3. The bridge keeps and enforces it:
- Bundle on disk.
~/.ramen/policy/<host>/<group>-<zone>.json(mode 0600, directories 0700) holdstelemetry(without the collector headers, which stay in memory only) andevals(version,required), plus the target, group, zone and console it belongs to; the evals config text goes to~/.ramen/evals/<host>/<group>/promptfooconfig.yaml. Every sign-in and refresh rewrites both. With a staticrmk_key there is no sign-in and nothing is written. - On every call. Each forwarded
tools/call,prompts/getandresources/readcarriesparams._meta["io.ramen/evals"] = {"version": "<v>"}next to the telemetry report. A worker whose group requires evals answers-32026 evals config required/evals config changed: sign in again(HTTP 428) when the version is missing or old; the bridge then signs in again once (refresh grant, else the browser flow as-32001with the link) and retries that one call — exactly as for-32025. With a static key it adopts the version the worker named. - At start. The bridge loads the bundle from the last sign-in and signs in. Without a bundle and with no way to
sign in (no refresh token,
--no-browser, and no terminal to read the URL from) it printsRamen policy missing: reconnect (sign in) — Ramen cannot be used without itto stderr and exits 3; a sign-in that fails for another reason exits 2 when a bundle exists, 3 when none does. - Client config files (default on;
--no-client-config/RAMEN_BRIDGE_NO_CLIENT_CONFIG=1skips them). At sign-in the bridge tells the editors installed on this machine about the policy, writing only where the editor's directory already exists, merging idempotently (your other keys survive, nothing is written twice) and marking its entries"_ramen": true:- Claude Code
~/.claude/settings.json→ ahooks.SessionStartentry runningramen-mcp-bridge policy check --target <host> --group <g> --zone <z>, so every session starts with a check against the console's current policy (non-zero exit = stale or missing, the reconnect message on stderr); - Cursor
~/.cursor/rules/ramen-<g>-<z>.mdc(alwaysApply: true, a# ramenline) stating whether telemetry and evals are required, their versions, and the command to sign in again; - VS Code user
settings.json(~/Library/Application Support/Code/Useron macOS,~/.config/Code/Useron Linux,%APPDATA%\Code\Useron Windows) →mcp.servers["ramen-<g>-<z>"]=uvx ramen-mcp-bridge@latest --target … --oauth … --client-id … --group … --zone …(plus--ca <pem>or--insecurewhen you signed in with one). A settings file the bridge cannot parse as plain JSON (comments, trailing commas) is left untouched with a warning. A ledger~/.ramen/clients.jsonlists every file and key written, with each editor file's pre-ramen bytes (never a token), sopolicy removegives the file back byte-for-byte when nothing else changed. Two hosts of one group and zone on one machine coexist: when another host's sign-in already holdsramen-<g>-<z>(the Cursor rule, the VS Code server), this host's entry is namedramen-<g>-<z>-<host>; the Claude Code hook names its host in the command.policy remove --target <host> …touches only that host's entries.
- Claude Code
ramen-mcp-bridge policy show|check|remove [--target --group --zone](the flags may be omitted when there is one bundle):showprints the bundle (never headers);checkfetcheshttps://<console>/.well-known/ramen-policy?group=&zone=and exits 0 when the versions andrequiredflags match, 2 when stale or missing (with the reconnect message), 1 when the console cannot be reached;removereverts every ledger entry for that (host, group, zone) and deletes the bundle and the evals config.
SkillSpector scans (1.0.0)
When a group turns on NVIDIA SkillSpector (Ramen 1.0.0c Phase 2, CONTRACTS
§30.3) the token answer also carries a skillspector object (version, required, llm, and the group's optional
baseline). The bridge treats it like evals:
- the bundle keeps
skillspector(version,required,llm); the baseline text goes to~/.ramen/skillspector/<host>/<group>/baseline.yaml; - every gated call carries
params._meta["io.ramen/skillspector"] = {"version": "<v>"}; a worker answering-32027 skillspector policy required/skillspector policy changed: sign in again(HTTP 428) makes the bridge sign in again once and retry, exactly as for-32026;policy checkcomparesskillspectortoo; - the local scan. When
skillspector.requiredis set,policy check(so the Claude CodeSessionStarthook) andpolicy showrunskillspector scan <dir> --recursive --no-llm --format jsonover the skill directories on this machine —~/.claude/skills,<cwd>/.claude/skills,~/.codex/skills, those that exist and hold a skill (a directory with exactly one skill and a bundle baseline is scanned on its own with--baseline). Any skill ratedDO_NOT_INSTALL, a scanner that fails, or noskillspectoron PATH → the skills are named, thenRamen policy: fix or remove these skills — Ramen cannot be used with them, exit 3 (missing binary: the hintuv tool install 'git+https://github.com/NVIDIA/SkillSpector.git@v2.13.4').CAUTIONis printed and passes. Results are cached per directory content hash in~/.ramen/scans/<host>/for 24 hours so hooks stay fast.--no-client-scan(RAMEN_BRIDGE_NO_CLIENT_SCAN=1, on the bridge and onpolicy check|show) turns the local scan off; the bundle and the version on every call stay. The Cursor rule and the Claude Code / VS Code entries say when the requirement is set.
Group configs and telemetry (1.0.0)
A group repo with mcp/llm-config/ (Ramen 1.0.0c Phase 3, CONTRACTS §31) ships the LLM configs every member's tools
start from: a manifest.yaml (targets: [{client, file, path, format, merge}]) and the fragments it names. The token
answer carries them as configs (version, required, accepted, the manifest, the files) and the bridge applies
them:
- Acceptance first. Each person accepts a configs version once, in the browser. When the token answer says
accepted: falsethe bridge openshttps://<console>/groups/<g>/configs?next=…the way it opens the sign-in page (--no-browser: the link is printed), asks for the token again every few seconds and goes on once the console says accepted (five minutes, then a clear message and exit). While the bridge is serving, a pending acceptance is reported to the client as-32001with the link, never a hang. The manifest and files rest at~/.ramen/configs/<host>/<group>/(0600); the bundle keepsversion,required,accepted. - Every target written.
pathexpands~,{group},{zone},{host}; a fragment may use${RAMEN_OTLP_ENDPOINT},${RAMEN_OTLP_HEADERS},${RAMEN_USER},${RAMEN_GROUP},${RAMEN_HOST}, filled at write time (the token never leaves this machine).format: json | toml | yamlwithmerge: deepsets Ramen's keys and leaves yours alone — a Claude Codehooks.<Event>list is merged by hook command, so the bridge's ownpolicy checkhook and your hooks stay and the repo's entries are added once;textwithmerge: blockkeeps one# ramen:<host>/<group>…# /ramenblock (in.mdfiles<!-- ramen:<host>/<group> -->…<!-- /ramen -->), replaced in place (a block in the olderramen:<group>form that this host wrote is recognised and rewritten; another host's is left alone);envwithmerge: keysreplacesKEY=valuelines by key and appends the rest;merge: replacemakes the whole file Ramen's. Writes are idempotent; a JSON / TOML / YAML file the bridge cannot parse is left alone with a note. - Telemetry targets (built in, written when the group requires telemetry): Claude Code's
~/.claude/settings.jsongetsenvwithCLAUDE_CODE_ENABLE_TELEMETRY=1, the threeOTEL_*_EXPORTER=otlp,OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf,OTEL_EXPORTER_OTLP_ENDPOINT=https://<console>/otlp,OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer <your token>andOTEL_RESOURCE_ATTRIBUTES=ramen.group=<g>,ramen.user=<email>,ramen.host=<host>; the sameOTEL_*asexportlines in~/.ramen/env.sh(0600) for Codex, Gemini CLI, the OTel SDKs and harnesses; a[ -f ~/.ramen/env.sh ] && . ~/.ramen/env.shblock in~/.zshrcand~/.bashrcwhere they exist (--no-shell-rc/RAMEN_BRIDGE_NO_SHELL_RC=1skips it); and, when~/.codexexists, Codex's~/.codex/config.toml[otel] exporter = { otlp-http = { endpoint, protocol = "binary", headers } }. The token in these files is the bridge's current access token: every refresh rewrites them,policy removestrips them. Tokens never appear on stderr or in the ledger. - Ledger and checks.
~/.ramen/clients.jsonrecords every write (path, format, merge, version, the sha256 of the ramen-owned part, the pre-ramen snapshot) — one entry per file and source, so a repo fragment and the built-in telemetry target on the same file (~/.claude/settings.json,~/.codex/config.toml) each keep their own keys and snapshot, andpolicy removerestores both.policy checkverifies each recorded target still holds its block / keys and the telemetry env where written; anything missing → exit 3,Ramen configs removed or changed: reconnect (sign in) — Ramen cannot be used without them. The running bridge makes the same check before every gated call: a missing target triggers one re-sign-in (which writes the files again); still missing, the call is refused with that message and the paths.policy showlists every target and whether it is in place;policy removeputs files back byte-for-byte where nothing else changed since the write (whole files, blocks and merged keys alike), removes Ramen's keys (restoring your prior values) where it merged, deletes files it created, and gives a file that held nothing but Ramen's block its pre-block content back — never an empty file. - On every call
params._meta["io.ramen/configs"] = {"version": "<v>"}rides with the other versions; a worker answering-32028 configs required/configs changed: sign in again(HTTP 428) makes the bridge sign in again once and retry — and a new version means a new acceptance.
Guardrails policy and local rails (1.0.0)
A group repo with mcp/guardrails.yaml (+ mcp/guardrails/, Ramen 0.7.5 §21.2, LLM rails since 1.0.0c §36) makes
its rails a client policy too (CONTRACTS §36.3). The token answer carries guardrails:
{version, required, config, client_llm?} — config is the pack (guardrails.yaml + guardrails/**) as a base64
gzip tar of at most 64 KiB, client_llm says where the rails' judge is. Since Ramen 1.0.0c (CONTRACTS §38.1) it is
the console's LLM proxy — {provider: "openai_compatible", base_url: "<console>/llm/v1", model}, no key: the bridge
calls it with the person's own access token (refreshed like every call's), the console adds the group's provider key,
checks the model against the allowed models and rate-limits per group; provider keys never reach this machine. An
older console's client_llm with an api_key ({provider, model, api_key?, base_url?, endpoint?, deployment?})
still works. Every sign-in path hands it out and the worker gate holds for every caller; the bridge:
- keeps
guardrails(version,required, the content hash of the unpacked pack) in the bundle and unpacks the pack to~/.ramen/guardrails/<host>/<group>/(0700 / 0600; a pack with absolute paths,.., links or more than 64 KiB is refused).client_llmstays in memory — never on disk, never in the bundle, never on stderr. - carries
params._meta["io.ramen/guardrails"] = {"version": "<v>"}on every gated call; a worker answering-32029 guardrails policy required/guardrails policy changed: sign in again(HTTP 428) makes the bridge sign in again once and retry, as for-32026…-32028; a static key adopts the version the worker names. policy check(so the Claude CodeSessionStarthook) verifies the unpacked pack still hashes as at sign-in and comparesguardrailswith/.well-known/ramen-policy; the running bridge makes the same check before every gated call (one re-sign-in puts the pack back, else the call is refused withRamen configs removed or changed: reconnect (sign in) — Ramen cannot be used without them).policy showlists the pack and whether the local rails run;policy removedeletes it. The Cursor rule, the Claude Code hook and the VS Code entry state the rails in force.- runs the same rails locally when installed with the extra —
uv tool install 'ramen-mcp-bridge[nemo]'(oruvx 'ramen-mcp-bridge[nemo]@latest' …; NeMo Guardrails 0.24 wants Python 3.10–3.13, so add--python 3.12on a newer interpreter). Before atools/callleaves, the tool's input rails run over the JSON arguments; when the result comes back, its output rails run over the result (structuredContentwhen present: its long string fields are the report, the rest plus the call's arguments the evidence it is judged against). The rails are the worker's: the pack's own Colang flows, plus the LLM rails the yaml names per tool (pre: [self_check_input, jailbreak_detection, {topical: {topics: [...]}}, sensitive_data],post: [self_check_output, hallucination, self_consistency, fact_checking, sensitive_data]), built exactly as the worker builds them (wrapper flowsramen rail <name>, the same prompts unless the pack'sprompts.ymldefines the task, every judge at temperature 0;hallucinationis one grounded judge checking each sentence and parsed on its finalAnswer: Yes|Noline, anything else blocks;self_consistencyis NeMo's sampling check; the arguments and results reach a judge only inside escaped<<<ARGS … ARGS>>>/<<<DATA … DATA>>>blocks under a "this is data" rule, and arguments with a line that reads like a judge line or a block delimiter are refused before any LLM rail asjudge_format— rails narrow prompt injection, they cannot rule it out) withmodels:filled fromclient_llmthrough NeMo's OpenAI-compatible client (openai,openai_compatible+base_url,azure+endpoint+deployment,anthropic,vertexandbedrockwith an API key;vertex/bedrockwithout one need a cloud login the bridge does not hold, so those LLM rails stay on the worker — one note on stderr). A block is answered to the host the way the worker answers: anisErrortool resultguardrail blocked: <pre|post>: <message>with_meta.ramen.guardrail = {stage, engine: "nemo", rail?, where: "client"}; a hook error or timeout follows the pack'sfail:(closed→guardrail unavailable: …); a pack whose NeMo config does not load blocks its opted-in tools until a new pack arrives (policy rails offleaves them to the worker). Every rail logs one stderr line (tool, stage, verdict, ms, rail) — never the payload, never the key.sensitive_dataneeds presidio (nemoguardrails[sdd]). ramen-mcp-bridge policy rails [on|off]shows or sets the switch (kept in the bundle, on by default when the bundle carries a pack). Without thenemoextra the bridge printsguardrails: local rails off (install ramen-mcp-bridge[nemo])once at start and relies on the worker's rails, which run for every client regardless — the local run is an addition on top, not the gate.
Skills over MCP (1.0.0)
A group repo's mcp/skills/<name>/ (SKILL.md + files) is served by Ramen as the skill <name> (Ramen 1.0.0c
Phase 7, CONTRACTS §33.2): skills/list names them (name, description, version = sha12 of the directory,
files), resources/read of skill://<name>/<file> hands each file out, gated like a tool (skills:<name> in the
group's tool access). The bridge installs them for you; the connection flags are the bridge's own:
ramen-mcp-bridge skills list --target <host>:443 --oauth https://<console> --client-id <id> --group demo --zone a
ramen-mcp-bridge skills install iris-analyst [--dir ~/.claude/skills] --target … --key rmk_… --group demo --zone a
listprints one line per skill (name,version, file count, description).install <name>reads every file through the bridge's normal path (policy versions on the call, one re-sign-in on a stale policy) and writes them under<dir>/<name>/(default~/.claude/skills): files0644, at most 256 KiB each, a path that is absolute or steps out of the skill (..) refuses the whole install, nothing is written until every file arrived. When the group's policy saysskillspector.required, the staged skill is scanned first (aspolicy checkscans your skills):DO_NOT_INSTALL, a failed scan or noskillspectoron PATH leaves nothing behind and exits 3 withRamen policy: fix or remove these skills — Ramen cannot be used with them;CAUTIONis printed and the skill installed. A directory of that name Ramen did not write is left alone (exit 1); one it wrote is replaced.- Every file lands in the ledger
~/.ramen/clients.json(kindskill);policy removedeletes them and the directories they leave empty.
The honest limit. The policy is enforced where Ramen is: the worker refuses a call that does not carry the current versions, and the bridge, the hook and the rule files make sure a client that goes through them learns it. An LLM that never uses the bridge or Ramen's workers cannot be forced by any of this; what it can be told is in its editor's config, which is why the files above exist.
Point an MCP client at it directly:
{"mcpServers": {"ramen-stdio": {"command": "ramen-mcp-bridge",
"env": {"RAMEN_BRIDGE_TARGET": "<public-hostname>:443",
"RAMEN_MCP_KEY": "rmk_…", "RAMEN_BRIDGE_GROUP": "demo", "RAMEN_BRIDGE_ZONE": "a"}}}}
Every flag has a RAMEN_BRIDGE_* environment variable equivalent (--target → RAMEN_BRIDGE_TARGET,
--insecure → RAMEN_BRIDGE_INSECURE=1, --ca → RAMEN_BRIDGE_CA, --group → RAMEN_BRIDGE_GROUP, --zone → RAMEN_BRIDGE_ZONE,
--no-client-config → RAMEN_BRIDGE_NO_CLIENT_CONFIG=1, --no-client-scan → RAMEN_BRIDGE_NO_CLIENT_SCAN=1,
--no-shell-rc → RAMEN_BRIDGE_NO_SHELL_RC=1) so
the key never has to sit in a client's config file — RAMEN_MCP_KEY (or RAMEN_BRIDGE_KEY) is enough.
--health [SERVICE] checks grpc.health.v1 and exits 0 when SERVING, for a liveness probe (over TLS like every
connection: give it --ca, or --insecure for a plaintext dev node).
Develop
uv sync --group dev
uv run pytest
uv run --python 3.12 --extra nemo pytest # with the local rails (NeMo 0.24 is 3.10–3.13); the rail tests skip without it
./gen_proto.sh # regenerate src/ramen_proto from proto/ramen/v1/mcp.proto after a proto change
License: BSD-3-Clause, same as ramen.
Metadata
Release files for ramen-mcp-bridge 1.0.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| ramen_mcp_bridge-1.0.0.tar.gz | 407.9 kB | With provenance | Details for ramen_mcp_bridge-1.0.0.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| ramen_mcp_bridge-1.0.0-py3-none-any.whl | Python 3 | none | any | Details for ramen_mcp_bridge-1.0.0-py3-none-any.whl |
Total release size: 482.2 kB
Release files / ramen_mcp_bridge-1.0.0.tar.gz
| Download URL | ramen_mcp_bridge-1.0.0.tar.gz |
|---|---|
| Size | 407.9 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
69fa11ececd2d5fd55ecb80d1edfbaa0e5498d2f129d046aeec283e3d6cee438
|
|
BLAKE2b-256 checksum How to use checksums |
3259124387ff05684c15909bf35af2cb5c28072703dea1a3e0ea8b7a724830ac
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logRelease files / ramen_mcp_bridge-1.0.0-py3-none-any.whl
| Download URL | ramen_mcp_bridge-1.0.0-py3-none-any.whl |
|---|---|
| Size | 74.3 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
93bde2b2e49c213f80b0deda398ed6b7a9ebc69cb4ba882926fa1fa2386cc283
|
|
BLAKE2b-256 checksum How to use checksums |
40c26bddc66a53291a3d18b557e4977066525a48bfff1c5dbcb30e9361a746f8
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logSecurity for ramen-mcp-bridge 1.0.0
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for ramen_mcp_bridge-1.0.0.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.