Medplum MCP
Securely access and manage FHIR healthcare data stored in Medplum.
Real-time conversation health for AI agents: drift, desync, causal collapse, plus mission clocks.
Lists are ordered by a usage score (out of 100) built from these parts
| Popularity | 0/80 | GitHub stars or weekly downloads: the larger counts 60, the smaller 20 |
|---|---|---|
| Freshness | 12/12 | Full marks for a release or code change within 30 days |
| Still answering | 8/8 | The cloud endpoint answered at the last check |
| Usage score | 20/100 |
Quality: Passed 3/5 basic checks (shown, not used for ordering) · Momentum: No data yet (Used only on the Trending tab)
Pick the AI app you use, then copy the settings.
Let your AI install it with one sentence
Please install Horizon Fidelity Monitor. Follow https://mcp.popnx.com/i/leocelis-horizon-fidelity-monitor.md, show me the commands and wait for my OK before running them.Paste it into an AI that can work on your computer (such as Claude Code or Cursor). It reads our steps, shows you the commands and waits for your OK. No key, no sign-up. · See the full text your AI reads
Passed 3/5 checks · What you ask goes through the maker’s server (horizon.leocelis.com) · ✓ Commands checked Nov 20, 2026
First: which AI do you use?
Pick your app and the steps appear below.
Works with Claude · about 5 min
You need a Horizon Fidelity Monitor key (create it on the maker’s site) · Set it up once on claude.ai or the desktop app, then use it in chat · free accounts can add 1 · on Team/Enterprise an Owner adds it
Open the maker’s site, sign up and create an API key for the next step. Check the maker’s site for pricing and free plans.
CustomizeConnectors
Copy each value into the field with the same name in Claude, then click Continue
Horizon Fidelity Monitorhttps://horizon.leocelis.com/sseUnder Request headers, add this name and value
AuthorizationBearer <paste your key here>Paste the key only into the app’s field, never into a chat or to anyone
Click Continue past the sign-in settings Claude detected · under Authentication choose what the maker says (Sign in now, Sign in when needed or No sign in), then click Add
+ConnectorsHorizon Fidelity Monitor
Use Horizon Fidelity Monitor and tell me what you can do for me, then show me one thing✓ If Claude says it is using Horizon Fidelity Monitor or shows a Horizon Fidelity Monitor tool in the answer, you are connected
Menu names checked against Anthropic’s help page on Nov 11, 2026 · your screen may differ slightly by app version
ChatGPT cannot connect Horizon Fidelity Monitor yet
Horizon Fidelity Monitor needs your own key to connect, but OpenAI’s help page only describes OAuth sign-in; there is no key option we could verify
A · Use an app that can connect Horizon Fidelity Monitor
B · Others in Clinics & health that work with ChatGPT
Picked from the most used in the same category, only ones that connect by address with no key
Works with Claude Code · about 5 min
You need a Horizon Fidelity Monitor key (create it on the maker’s site)
Open the maker’s site, sign up and create an API key for the next step. Check the maker’s site for pricing and free plans.
Mac: press Command+Space and type Terminal · Windows: open PowerShell
claude mcp add --transport sse --scope user horizon-fidelity-monitor https://horizon.leocelis.com/sse --header 'Authorization: Bearer {api_key}'Replace “your-value” with your key before pressing Enter
Paste the key only into the app’s field, never into a chat or to anyone
You should see Horizon Fidelity Monitor listed as connected
Use Horizon Fidelity Monitor and tell me what you can do for me, then show me one thing✓ If Claude Code says it is using Horizon Fidelity Monitor or shows a Horizon Fidelity Monitor tool in the answer, you are connected
Menu names checked against Anthropic’s help page on Nov 11, 2026 · your screen may differ slightly by app version
Works with Cursor · about 5 min
You need a Horizon Fidelity Monitor key (create it on the maker’s site)
Open the maker’s site, sign up and create an API key for the next step. Check the maker’s site for pricing and free plans.
In the Horizon Fidelity Monitor settings, Authorization is empty; add your key and save
Paste the key only into the app’s field, never into a chat or to anyone
Use Horizon Fidelity Monitor and tell me what you can do for me, then show me one thing✓ If Cursor says it is using Horizon Fidelity Monitor or shows a Horizon Fidelity Monitor tool in the answer, you are connected
Menu names checked against Cursor’s help page on Nov 11, 2026 · your screen may differ slightly by app version
Works with VS Code · about 5 min
You need a Horizon Fidelity Monitor key (create it on the maker’s site)
Open the maker’s site, sign up and create an API key for the next step. Check the maker’s site for pricing and free plans.
In the Horizon Fidelity Monitor settings, Authorization is empty; add your key and save
Paste the key only into the app’s field, never into a chat or to anyone
Use Horizon Fidelity Monitor and tell me what you can do for me, then show me one thing✓ If VS Code says it is using Horizon Fidelity Monitor or shows a Horizon Fidelity Monitor tool in the answer, you are connected
Menu names checked against VS Code’s help page on Nov 11, 2026 · your screen may differ slightly by app version
Other apps that use MCP, such as Windsurf, Zed or Gemini CLI, each add servers differently. See how in the app list.
Address for apps that connect over the web
https://horizon.leocelis.com/sseJSON settings are under “For developers” below
Claude Code
claude mcp add --transport sse --scope user horizon-fidelity-monitor https://horizon.leocelis.com/sse --header 'Authorization: Bearer {api_key}'Cursor (~/.cursor/mcp.json)
{
"mcpServers": {
"horizon-fidelity-monitor": {
"url": "https://horizon.leocelis.com/sse",
"headers": {
"Authorization": "Bearer {api_key}"
}
}
}
}VS Code (mcp.json)
{
"servers": {
"horizon-fidelity-monitor": {
"type": "sse",
"url": "https://horizon.leocelis.com/sse",
"headers": {
"Authorization": "Bearer {api_key}"
}
}
}
}Descriptions are as written by the maker.
These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.
Based on how this server connects and on each app’s own docs, checked Nov 10, 2026.
Connect over the internet in
ClaudeGooseLM StudioMsty StudioCherry StudioCursorVS Code + GitHub CopilotVisual StudioWindsurf (Devin Desktop)ZedKiroClineContinueJetBrains AI AssistantClaude CodeCodex CLIGemini CLIOpenCodenodecodeWarpLibreChatOpen WebUIRaycast
The server asks you to sign in before it lists its tools.
We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 20, 2026
The registry name was verified with the GitHub account leocelis, which owns the repo
Code last changed 3 days ago
Uses MIT
Refused access (HTTP 401) without offering OAuth sign-in. It may need a key, or it may be blocking bots; not confirmed.
Needs a key or token that you copy and paste yourself
Not checked yet; we read the tool list when we check the endpoint
If you made this, paste this code into your README. The badge links back to this page.
[](https://mcp.popnx.com/en/servers/leocelis-horizon-fidelity-monitor)Ask, share a tip or report that it does not work. Sorted by what people marked helpful.
No posts yet. Be the first to ask or share.
Posts here are written by users, not the PopNx team.
No reviews yet
Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.
It passed 3 of 5 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.
You need to fill in: Authorization
It runs in the maker’s cloud. Connect over the internet with nothing to install, but what you send passes through the maker’s servers.
The GitHub repo last changed 3 days ago, and the latest version (0.3.2) reached the registry 12 days ago.
Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. It connects by URL, so apps that accept remote MCP servers work too, such as ChatGPT on the web (full MCP on Business and above; Pro read-only).
In the same category: Medplum MCP, Mirobody, Codescene MCP Server, Marrow, WHOOP — MissingMCP
Same category, other makers, commands already checked. Official ones first, then by stars.
Reading a card:↓ Downloads per weeki★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi
Securely access and manage FHIR healthcare data stored in Medplum.
Lab results to LOINC codes and UCUM units, symptoms and diagnoses to ICPC-3. Offline, no API key.
An MCP server that provides CodeScene Code Health analysis tools.
Marrow Health: your Apple Health data over MCP, from the free iOS app. Reads, and writes on demand.
WHOOP recovery, strain, sleep and workouts in Claude via official WHOOP OAuth. Free, open source.
| This one Horizon Fidelity Monitor | Medplum MCP | Mirobody | Codescene MCP Server | Marrow | WHOOP — MissingMCP | |
|---|---|---|---|---|---|---|
| Runs where | Runs in the cloud, nothing to install | Runs in the cloud, nothing to install | Installs on your computer | Installs on your computer | Installs on your computer | Runs in the cloud, nothing to install |
| Needs a key | Yes | No | No | No | No | No |
| Add with + in Claude | No | No | No | No | No | No |
| Basic checks | 3/5 | 4/4 | 3/3 | 2/3 | 3/3 | 2/4 |
| License | MIT | Apache-2.0 | Apache-2.0 | NOASSERTION | MIT | MIT |
| Price | No cost listed in the registry | No cost listed in the registry | No cost listed in the registry | No cost listed in the registry | No cost listed in the registry | No cost listed in the registry |
Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.
"Quality is not a model property — it is a conversation property."
Horizon is a real-time conversation health monitor for AI agents. It tracks the structural dynamics of multi-turn conversations — semantic drift, information gain, ontological gap width, temporal desynchronisation, circadian cognitive load, conversation velocity, and causal reachability — dimensions that LLMs do not reliably surface from inside the conversation.
Horizon ships two measurement planes. The conversation plane (above, always present) measures the health of a dialogue turn by turn. The optional mission plane — *Memento Mori* — measures elapsed calendar time against goals: ages, deadlines, stalls, per-entity latency, and share of a finite horizon. It is inert until you configure a store. See Mission plane.
Horizon is not a manipulation, sycophancy, or human-influence detector — it measures conversation *dynamics*, not whether an agent is steering or flattering the user. See LEGAL.md §1.
Why an external monitor? LLMs have *limited and unreliable* self-knowledge: introspection research shows partial self-access that is brittle and degrades on complex or out-of-distribution tasks (Binder et al. 2024; arXiv:2512.12411). So rather than depend on a model reporting its own conversation dynamics, Horizon measures them externally with cheap, deterministic, always-on arithmetic over a small local embedding model, with no LLM calls.
Multi-turn AI agents lose accuracy. The ICLR 2026 oral paper "LLMs Get Lost In Multi-Turn Conversation" (Laban, Hayashi, Zhou & Neville) reports an average 39% performance drop across six generation tasks when instructions arrive over multiple turns — a structural property that standard observability tools (LangSmith, RAGAS, DeepEval) cannot see because they measure responses, not conversations.
Horizon was built to close that gap. It is observability first: it surfaces conversation dynamics that response-level tools miss, using cheap deterministic arithmetic and a small local embedding model, with no LLM calls. In four controlled A/B scenarios where Horizon events drove a re-grounding intervention we measured a +15.7% composite quality lift and 87% fewer hallucination events — but those are *synthetic, scripted scenarios with a hand-tuned controller*, not a production result. Treat them as promising in-house evidence, not a guaranteed outcome (see Validation and LEGAL.md §5). Every signal — information gain, divergence, estimated ontological gap width, causal reachability — is a standard information-theory or arithmetic measure computed on text embeddings and timestamps; see 4D Spacetime Signals for the full definitions.
docs/content/naming-the-category-conversation-dynamics-monitoring.mddocs/content/why-every-production-agent-needs-conversation-dynamics-monitoring.mdThree paths — pick the one that fits your workflow:
The fastest way to add Horizon to any Cursor, VS Code, or Claude Desktop workspace. No Python required.
Request an alpha key → open a Discussion, then add the config for your client:
Cursor (~/.cursor/mcp.json):
{
"mcpServers": { "horizon": { "url": "https://horizon.leocelis.com/sse", "headers": { "Authorization": "Bearer YOUR_KEY_HERE" } } } }
VS Code / GitHub Copilot (.vscode/mcp.json in your workspace):
{
"servers": { "horizon": { "type": "http", "url": "https://horizon.leocelis.com/sse", "headers": { "Authorization": "Bearer YOUR_KEY_HERE" } } } }
VS Code note: Use
"servers"(not"mcpServers") and"type": "http"— VS Code tries Streamable HTTP first and falls back to SSE automatically, so"type": "http"works with the/sseURL.
Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": { "horizon": { "url": "https://horizon.leocelis.com/sse", "headers": { "Authorization": "Bearer YOUR_KEY_HERE" } } } }
That's it. Reload your MCP client and three tools appear: new_conversation, process_turn, configure_session. With a mission store configured, seven more appear: clock_register, clock_progress, clock_status, clock_propose, clock_ack, clock_close, associate_mission (see Mission plane).
Alpha access: Horizon's hosted endpoint is in private alpha. Keys are distributed to agent developers who want to monitor real projects. Open a Discussion to request one — describe your use case and we'll send a key.
Python 3.10–3.14.
pip install horizon-monitor
Verify your install (exercises the full pipeline on 5 canonical scenarios, ~25s):
horizon-validate
git clone https://github.com/leocelis/horizon && cd horizon
pip install -e '.[mcp]' horizon serve # stdio — for Cursor, Claude Desktop horizon serve --transport sse --port 3847 # SSE — for web/team deployments
Add to ~/.cursor/mcp.json:
{
"mcpServers": { "horizon": { "command": "horizon", "args": ["serve"] } } }
Full Cursor and Claude Desktop setup guides: docs/integrations/
Standard observability tools evaluate individual response quality. Horizon evaluates conversation quality — a structurally different problem:
| Tool | What it sees | What it misses |
|---|---|---|
| LangSmith, Braintrust | Latency, cost, per-response quality | Deterministic, every-turn structural signals |
| RAGAS, DeepEval | Faithfulness, relevance per turn (DeepEval also has sampled multi-turn LLM-judge metrics) | Zero-LLM-call, real-time scoring on every turn |
| Langfuse, Arize Phoenix | Session-level LLM-judge evaluation | Deterministic, always-on scoring at sub-50ms |
| Human raters | Subjective quality | Systematic structural decay |
| Horizon | Conversation dynamics | Intentionally nothing |
Horizon does not replace per-response or LLM-judge quality tools. The differentiator is *how* it measures: deterministic, zero-LLM-call arithmetic on every single turn — effectively free and always-on — versus the alternative of sampled LLM-judge evaluations, which cost per sample and typically run offline or async rather than in real time.
from horizon_monitor import FidelityMonitor
from datetime import datetime, timezone
monitor = FidelityMonitor() session_id = monitor.new_conversation(metadata={"domain": "technical"})
result = monitor.process_turn( session_id, human_message="How does Python handle memory management?", agent_response="Python uses reference counting and a cyclic garbage collector...", timestamp=datetime.now(timezone.utc).isoformat(), )
print(f"Fidelity: {result.fidelity_score:.2f}") print(f"Health: {result.health_status}") print(f"Circadian factor: {result.circadian_factor:.2f}") print(f"Causal horizon: {result.reachable_turns} reachable turns") for event in result.events: print(f" Event: {event.type} (confidence={event.confidence:.2f})")
from openai import OpenAI
from horizon_monitor import FidelityMonitor
monitor = FidelityMonitor() session_id = monitor.new_conversation() client = monitor.wrap(OpenAI(), session_id)
response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": "Tell me about quantum computing."}] )
traj = monitor.get_trajectory(session_id) print(f"Fidelity: {traj.current_fidelity:.2f} T*: {traj.estimated_t_star}")
monitor.wrap() accepts custom timestamp and context providers for testing and replay.
from anthropic import Anthropic
from horizon_monitor import FidelityMonitor
monitor = FidelityMonitor() session_id = monitor.new_conversation() client = monitor.wrap(Anthropic(), session_id)
response = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=1024, messages=[{"role": "user", "content": "Explain RLHF."}] )
from langchain_openai import ChatOpenAI
from horizon_monitor import FidelityMonitor from horizon_monitor.integrations.langchain import HorizonCallback
monitor = FidelityMonitor() session_id = monitor.new_conversation() callback = HorizonCallback(monitor, session_id)
llm = ChatOpenAI(callbacks=[callback]) llm.invoke("Explain the CAP theorem.") print(f"Fidelity: {callback.last_result.fidelity_score:.2f}")
from agents import Agent, Runner
from horizon_monitor import FidelityMonitor
monitor = FidelityMonitor() session_id = monitor.new_conversation() agent = Agent(name="assistant", model="gpt-4o-mini", instructions="You are helpful.")
for user_message in conversation: result = Runner.run_sync(agent, user_message) monitor.process_turn(session_id, human_message=user_message, agent_response=result.final_output, timestamp=datetime.now(timezone.utc).isoformat())
"Spacetime" here is a metaphor, not physics. The relativity vocabulary (Minkowski interval,
light cone, proper time) is *design inspiration* — it shaped which quantities we compute. Every
signal below reduces to a standard information-theory or arithmetic measure on text embeddings and
timestamps, listed in the Plain definition column. Nothing in Horizon's behavior or validation
depends on the analogy being literally true, and the Lorentzian
interval_classis emitted as
descriptive metadata only — no event or score depends on it.
Every process_turn() returns a TurnResult with 33 fields across six signal families:
| Signal | Description |
|---|---|
fidelity_score | Composite conversation health [0, 1] |
igt_value | Information Gain per Turn — semantic novelty |
divergence_score | Jensen-Shannon proxy for intent/response gap |
twr_value | Token Waste Ratio — semantic redundancy |
consistency_score | Bipredictability — structural coherence |
epsilon_t | Estimated ontological gap width [0, 1] |
health_status | healthy / degrading / critical / converged |
conversation_mode | execute / explore / refine / learn (auto-detected) |
timestamp)| Signal | Description |
|---|---|
gap_seconds | Wall-clock gap since last turn |
estimated_retention | Human memory retention (Ebbinghaus half-life model) |
| circadian_factor | Human cogn