Refract MCP Server
Can use Ollama as a local OpenAI-compatible LLM endpoint, with configuration examples and preflight checks for structured output, context window, and hidden reasoning.
Supports OpenAI-compatible LLM endpoints for tagging, planning, drafting, revising, verification, and chat, with per-step model routing, failover, cost accounting, and disk caching.
Fetches and deduplicates RSS/Atom news feeds into events, and ranks stored news for a subject by relevance before analysis.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Refract MCP Servershow me the personalised news feed for demo_building_materials"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Refract
A traceable LLM agent that turns a news event into a grounded, personalised insight — for a company, a sole proprietor, a self-employed person or a private individual.
One piece of news means different things to different readers. Refract refracts it through the profile of each reader: what happened, why it matters to them, which risks and opportunities follow, what the institution's analysts think, and what can be done next. Every statement carries its origin — fact, house view, AI inference or hypothesis — and the sources it rests on. Code, not the model, enforces grounding, caps the impact level and decides which products may be offered. Every step is recorded in a trace.
ev_rate_hold_ru × demo_building_materials (wholesaler with loans, a developer as its largest customer)
→ headline The 14% rate stays: cheaper loans and leasing are postponed
→ why [AI inference] loans and leasing — debt service will not get cheaper (features: products.loans …)
[Hypothesis] the largest customer is a developer (31% of incoming payments) …
→ house view [Demo Bank view] rate to stay at 14% until end-2026 (p. 2 of the macro outlook)
→ action discuss fixing the rate — product: fixed-rate loan (rule fix_rate fired)
→ trace rule check caught an invented “1.2 bn” → revision → policy removed a product no rule allowsContents
Related MCP server: finance-pulse
Why Refract
Personalised, not summarised. Every “why it matters” statement must cite features of the subject (
products.loans,counterparties.customer.cp_dev_101,tax_regime…). Unknown feature keys are rejected by code.Provenance on every statement.
fact·house_view·ai·hypothesis. A statement attributed to the institution must cite its research; a fact must cite a source; a hypothesis carries a caveat.Deterministic guard rails. Numbers absent from the context are caught; the impact level is capped by a ceiling computed from subject–event links; products appear only when a policy rule fired on the subject's features. A prompt injection in the news cannot raise the impact or add a product.
Self-verification. Rule checks plus a review by a second model; the agent searches for more data, revises, and cuts what still fails.
Any subject. Companies, sole proprietors, self-employed people and private individuals, with reader roles from CFO and treasurer to “entrepreneur” and “individual”.
Bilingual. Insights in Russian or English, whatever the language of the news.
Provider-agnostic. Any OpenAI-compatible endpoint: OpenAI, OpenRouter, LiteLLM, vLLM, Ollama, LM Studio — with per-step model routing, failover, cost accounting and a disk cache.
A personal feed. Of a hundred news items, code picks the few that concern this subject and says why, before any model is asked.
Ready to integrate. A web page, Python API, CLI, REST API with live progress (SSE), MCP server, RSS collector.
Ready to study. Built-in ablations, baselines, multiple LLM judges, inter-judge agreement and bootstrap confidence intervals.
How it works
flowchart TB
IN([Subject profile + news event]) --> P[Profile tool]
P --> T{Event tagged?}
T -- no --> C[Tag the news: type, factors,<br/>NACE codes, countries, importance]
T -- yes --> PL
C --> PL[Plan: 3–6 tool calls]
PL --> TL[Tools: house view, research search,<br/>counterparties, group, related news]
TL --> D[Draft insight by JSON schema]
D --> A[Attribution: features and sources<br/>the model left out]
A --> V[Self-check: rule checks + second model]
V -- errors, data missing --> M[Extra research search]
M --> R[Revise]
V -- errors --> R
R --> A
V -- clean or rounds exhausted --> F[Finalize: cut unsupported statements,<br/>cap impact, enforce action policy,<br/>rewrite a rejected headline]
F --> OUT([Insight + trace])Component | Where | What it does |
Orchestrator |
| the loop above; |
Context |
| subject features with keys, the event, links, the house view, the source registry |
Impact ceiling |
| strength of each subject–event link → the highest impact level allowed |
Rule checks |
| sources, origins, feature keys, numbers, the ceiling; attribution repair, pruning and restoring |
Action policy |
| which rules fire; product names, one product per insight, manager first on high negative impact |
Chat |
| follow-up questions on the same context, with the same checks |
Prompts |
| every step in Russian and English, versioned |
Details: docs/agent.md · docs/architecture.md · docs/data-model.md.
Quick start
Requires Python 3.10+. With uv:
git clone https://github.com/Rinneway/refract.git
cd refract
uv sync --all-extras
uv run refract demo # scripted run — no API key needed
uv run refract demo injection # a news item with a prompt injection
uv run refract demo dollar # an English run: a misattributed house view and a rejected headlineThe demo scripts the model's answers; tools, retrieval, rule checks, the impact ceiling, the action policy and the trace are real.
With a model:
cp .env.example .env # set LLM_BASE_URL, LLM_API_KEY, REFRACT_MODEL
uv run refract profiles # synthetic subjects in examples/demo
uv run refract events
uv run refract analyze --profile demo_coffee_ip --event ev_usn_vat_ru --role entrepreneur --lang en --out runs/
uv run refract analyze --profile demo_family_saver --role individual \
--title "Mortgage rates fall below 18%" --text-file news.txt
uv run refract chat --run runs/<insight_id>.json --q "What does it mean for my plans to open a bakery?"Free: Ollama locally (Ollama Cloud now bills in credits beyond a few starter models) — copy examples/config/ollama-local.toml or ollama-cloud.toml to refract.toml and run uv run refract check: it verifies structured output, the context window and hidden reasoning before you spend time on runs. Providers without native structured output fall back to JSON mode and then to the schema in the prompt.
With pip: pip install "refract-agent[api,mcp,pdf] @ git+https://github.com/Rinneway/refract".
Interfaces
Python
from refract import Refract
rf = Refract.from_dir("examples/demo")
run = rf.analyze("demo_london_studio", "ev_dollar_en", role="cfo", language="en")
print(run.insight.headline, run.insight.overall_impact)
for claim in run.insight.why_it_matters:
print(claim.origin.value, claim.text, claim.source_ids, claim.features)
answer = rf.chat(run.insight.insight_id, "Should we hedge?").responseWeb page — uv run refract serve and open http://127.0.0.1:8000/: pick a subject, see which news concern it, click one and watch the agent work; every statement is marked with where it comes from, with its sources, follow-up questions and the trace of how it was produced. One self-contained page on the REST API, no build step.

REST API — uv run refract serve, OpenAPI docs at /docs:
curl -s localhost:8000/insights -H 'content-type: application/json' \
-d '{"profile_id": "demo_grain_farm", "event_id": "ev_wheat_en", "language": "en"}'
# → {"job_id": "…"}; live steps: curl -N localhost:8000/jobs/<job_id>/streamMCP — uv run refract mcp exposes list_profiles, news_feed, analyze_news, ask_followup, get_trace, search_research to Claude Desktop, Cursor and other MCP clients.
News — refract news fetch --feeds examples/feeds.example.json --data my_data collects RSS/Atom feeds into deduplicated events (titles, links, feed summaries; no full texts). refract feed --profile demo_coffee_ip ranks the stored news for one subject by code — which concern it directly, which are background, and why; --analyze 3 explains the top three.
Your own research — put Markdown, text or PDF files into knowledge/docs/; refract theses --docs … --out knowledge/theses.json extracts the institution's theses and keeps only those whose quote is found verbatim on the page.
All interfaces: docs/integrations.md.
Configuration
Environment variables (or .env) override refract.toml (see refract.example.toml).
Variable | Default | Purpose |
|
| endpoint; several, comma-separated, are tried in order |
| — | key for the endpoint |
|
| model for tagging, planning, drafting, revising and chat |
| = | model for the review step and default judge; another family is better |
|
| language of insights: |
| — | enables hybrid BM25 + dense retrieval |
|
| folder with |
| — | require |
In refract.toml you can also route each step to its own model, set prices for cost accounting, name the institution whose research forms the house view, switch product offers off, and point to your own roles and action rules. See docs/configuration.md.
Evaluation and research use
refract eval pairs --data examples/demo --out runs/exp1/pairs.jsonl --languages ru,en
refract eval run --out runs/exp1 --systems full,no_plan,no_verifier,no_rules,no_cap,no_policy,single_call,retelling
refract eval judge --out runs/exp1 --judges verifier,judge2
refract eval label export --out runs/exp1 --sample 40 # optional: a blinded sheet for human labels
refract eval label import --out runs/exp1
refract eval report --out runs/exp1 --reference fullSystems: the full agent, nine ablations (
no_plan,no_verifier,no_rules,no_revise,no_self_check,no_cap,no_policy,no_attribution,no_reconcile) and two baselines (single_call— the same prompt and house view in one call;retelling— one call with a plain prompt).Judge metrics: six questions scored 0–2 (what happened, why it matters, consequences, actions, house view, grounding), overall 1–5, unsupported statements, retelling and impact calibration.
Code metrics that need no judge: rule errors reaching the reader, invented numbers, impact above the computed ceiling, answers not in the requested language, cost, latency; results are also split by output language.
Human labels: a blinded, shuffled sheet with the judge's rubric; imported as one more judge, so the report shows how far each LLM judge agrees with people.
Statistics: 95% bootstrap CIs, paired differences, sign tests, quadratic-weighted κ and Spearman for every pair of judges, accuracy and κ against human labels.
Reproducibility: prompt versions and the agent configuration are written into every trace; model answers are cached by request hash.
Method, metrics and threats to validity: docs/evaluation.md. A plan for a paper: docs/paper/outline.md.
Project layout
src/refract/
agent/ orchestrator, context, tools, checks, impact ceiling, action policy, chat, progress
prompts/ prompts of every step, ru + en
schemas/ Pydantic contracts and the shared vocabulary (factors, NACE, ISO countries)
knowledge/ data store, BM25 / hybrid retrieval, document ingestion, thesis extraction
llm/ OpenAI-compatible client, scripted model for tests and demos
eval/ experiments, judges, statistics, report
news/ RSS / Atom collector
policies/ reader roles and action rules (JSON)
api.py mcp_server.py cli.py facade.py render.py demo.py
examples/demo/ synthetic profiles, news, research and evaluation pairs (ru + en)
docs/ architecture, agent, data model, configuration, integrations, evaluation, paper outline, JSON Schemas
tests/ 159 tests on a scripted model and a fake OpenAI-compatible server — no network neededData and confidentiality
Refract grew out of the author's agent component in an earlier team project on news analytics. That project worked with data and documents that cannot be published, so this repository is a standalone re-implementation and contains none of them: no client data (even anonymised), no internal research or theses, no infrastructure addresses, no keys. Everything in examples/ — subjects, news, research notes and the “Demo Bank” itself — is invented; numbers in it do not describe real events. A test fails if strings shaped like client ids of the original data or like API keys appear anywhere in the repository. Details: docs/provenance.md.
Limitations
Insights are only as good as the profile: the agent sees what the profile says and nothing else; it does not know about products at other institutions.
Number checks match numbers against the whole context, not the cited source; a number that appears elsewhere in the context passes.
The impact ceiling and the action policy are hand-written rules; thresholds are configurable but not learned.
English prompts are translations of prompts tuned on Russian news; check them with the parity run in docs/evaluation.md before relying on them.
An LLM judge is not a human expert; report agreement between judges and validate on human labels.
Refract produces information, not individual investment, tax or legal advice.
Citing
If you use Refract in research, please cite it via CITATION.cff (GitHub shows a “Cite this repository” button).
License
MIT. Contributions are welcome — see CONTRIBUTING.md.
Available Tools
8 toolsanalyze_newsC
Run the agent: what the news means for the subject. Give an event_id, or a title and text. role: owner, ceo, cfo, chief_accountant, treasurer, entrepreneur, individual, other. language: ru or en.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | ||
| role | No | cfo | |
| text | No | ||
| title | No | ||
| event_id | No | ||
| language | No | ru | |
| publisher | No | user | |
| profile_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden, and it discloses very little. 'Run the agent' hints at an LLM-backed, non-deterministic and potentially costly invocation, but latency, cost, determinism, and failure modes are never mentioned; 'what the news means for the subject' gives only a vague sense of the output. The existence of an output schema spares it from describing return values, which limits the penalty.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loads the core purpose before the input alternatives and enumerations. The telegraphic 'role: ... language: ru or en' style is efficient, though slightly cryptic and mixed with the usage sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 8-parameter tool with a required profile_id, zero annotation coverage, and zero schema descriptions, the definition is thin. It never explains what profile_id is or why it is required, nor what 'the subject' refers to, and it gives no behavioral context for an agent-run analysis.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does partially: it clarifies the event_id-versus-title/text alternative and lists allowed values for role and language that are absent from the schema (role has no enum despite the description enumerating eight values). However, it omits url, publisher, and critically the required profile_id, leaving several parameters undocumented anywhere.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description says it will 'Run the agent: what the news means for the subject,' which conveys that this is an analysis/interpretation tool rather than a raw feed, distinguishing it implicitly from siblings like news_feed and list_events. However, 'Run the agent' is vague phrasing and the subject of the analysis is never defined, so an agent cannot be fully certain what the tool produces without reading the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Give an event_id, or a title and text' explains how to supply input but says nothing about when to choose this tool over news_feed, list_events, or search_research. There are no exclusions, no prerequisites, and no statement of when interpretation is warranted versus simply fetching news.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ask_followupC
A follow-up question about an insight produced in this session.
| Name | Required | Description | Default |
|---|---|---|---|
| question | Yes | ||
| insight_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden: it does not say whether this is a read-only lookup or an expensive model-backed query, whether it can fail on unknown insight_ids, or whether there is any rate/cost implication. The only behavioral hint is the phrase 'in this session', implying session-scoped state, which is useful but thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The text is a single short fragment with no padding, so there is nothing to trim. But brevity here comes from under-specification rather than precision – it omits the verb and any operational detail the agent needs.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described. Still, for a two-parameter tool with zero schema coverage and no annotations, the definition leaves the agent guessing about the source of insight_id and the tool's execution characteristics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for both parameters, so the description must compensate and does not: it never clarifies that insight_id is an identifier for a previously produced insight (or where to get one), nor what form the question should take. At most, 'an insight produced in this session' weakly implies the provenance of insight_id.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The fragment conveys intent – posing a follow-up question about an insight already produced in the session – which distinguishes it from siblings like search_research or analyze_news. However, it is a noun phrase with no verb, so it never states the action (ask/submit/generate an answer) or what the tool actually does with the question.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this versus the sibling tools, and no prerequisites stated beyond the implied 'insight produced in this session'. Nothing tells the agent whether the insight_id must come from a prior call in the same session or how to obtain it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_profileC
The full profile of a subject as JSON.
| Name | Required | Description | Default |
|---|---|---|---|
| profile_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden, and it only discloses the response encoding (JSON). It does not state that the operation is read-only, what happens when profile_id is unknown (empty result vs error), any authorization or visibility constraints, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with the resource and return format front-loaded and zero filler. It is efficient, though its brevity reflects under-specification rather than disciplined compression.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a simple single-parameter read with an output schema, so return values need not be described. However, with no annotations and 0% schema coverage, the description should at minimum identify what profile_id refers to and confirm read-only semantics, which it omits.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for the single parameter, so the description needed to define what profile_id actually is (a numeric user id, a handle, an internal identifier, a subject slug). It adds no meaning beyond the bare property name and required flag.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
"The full profile of a subject as JSON" names a specific resource (a subject's profile) and implies retrieval of the complete record, which separates it from the listing behavior implied by the sibling list_profiles. It stops short of explicitly contrasting with list_profiles or stating what 'subject' means, so it is clear but not sibling-differentiating.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance at all: nothing says when to call get_profile instead of list_profiles, get_trace, or search_research, and no prerequisites (e.g., needing a known profile_id) are stated. The agent must infer the use case purely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_traceB
How an insight was produced: every tool call and model call with timing, cost and review findings.
| Name | Required | Description | Default |
|---|---|---|---|
| insight_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does useful work by disclosing the returned payload (tool calls, model calls, timing, cost, review findings), from which an agent infers this is a read-only, non-destructive lookup. It does not state what happens if the insight_id is unknown, whether traces can be partial or truncated, or any permission requirement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence that defines the resource in the first clause and then enumerates its contents. No filler, no restatement of the tool name, and the most important information leads.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one required parameter) and an output schema exists, so return-value explanation is not strictly required. However, with no annotations at all and no parameter documentation in the schema, the description should say more about the ID's origin and read-only/error behavior. It is adequate but leaves the single input under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the input schema gives no title or description for insight_id. The description only indirectly implies the parameter by saying 'How an insight was produced,' and never says what an insight_id looks like, where to obtain one, or whether the ID must come from analyze_news. For a zero-coverage schema this leaves a real gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource concretely (the provenance of an insight) and enumerates the contents of the trace: 'every tool call and model call with timing, cost and review findings.' An agent can tell this is a provenance/audit retrieval tool. It lacks an explicit verb and does not name or contrast any sibling, but the siblings listed (news_feed, list_events, get_profile, analyze_news) are distant enough that confusion is unlikely.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use statement is given, and no alternative is named. Usage is only implied by the phrase 'How an insight was produced' — i.e. call this to explain or audit an existing insight. An agent must infer that this is an after-the-fact explainability call rather than a discovery call.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_eventsC
Latest news events in the store.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden and delivers almost nothing. It does not disclose ordering ('latest' by what field?), whether results are capped or paginated, freshness/refresh behavior, or any auth or scope constraints. The existence of an output schema excuses return-value description, but the operational behavior remains opaque.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single short sentence with no filler and a front-loaded noun phrase. It is efficient, though the brevity is closer to under-specification than to disciplined conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one optional integer, output schema present), which lowers the bar, but the description still fails to explain the recency semantics behind 'latest' or how this differs from news_feed. For a list tool with an unlabeled limit parameter, that is a meaningful shortfall.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is one parameter, limit, with 0% schema description coverage, so the schema contributes no semantics. The description only hints at relevance via 'latest' and says nothing about what limit counts (events, days?) or what the default of 20 means in practice, leaving a real gap for the single knob the caller can turn.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The phrase 'Latest news events in the store' identifies the resource (news events) and implies a listing/recency behavior, but never states a verb and never distinguishes the tool from the sibling news_feed or analyze_news. An agent can guess it fetches a recent-events list, but cannot tell why it would pick this over news_feed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance, no exclusions, and no reference to any alternative. With news_feed and analyze_news in the sibling set, the lack of routing guidance leaves the selection decision entirely to guesswork.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_profilesC
Subjects available for analysis: id, kind and a short summary.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden, yet it only enumerates return fields. It does not state that the call is read-only, whether it returns all profiles or a filtered set, or anything about ordering or pagination.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is a single short sentence with no wasted words, but it is structured as a colon-separated field list rather than a front-loaded statement of what the tool does. It is concise to the point of under-specification.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so the description need not explain return values, and its field list is reasonable duplication. However, for an agent deciding between this and get_profile, the definition omits the listing scope and any usage context, leaving it only minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is no parameter semantics to add beyond the schema. The baseline of 4 applies for a no-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The phrase 'Subjects available for analysis: id, kind and a short summary' identifies the resource (profiles/subjects) and its returned fields, but it reads as a noun phrase rather than a clear action. It never states that it lists all profiles, and it does not explicitly differentiate itself from the sibling get_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance at all: no indication of whether this should be called before get_profile, no mention of alternatives, and no prerequisites or context. The agent must infer usage purely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
news_feedA
Which stored news concern the subject, strongest links first — ranked by code, with the reason for each. since: YYYY-MM-DD. Use analyze_news on an event_id from the list to get the full insight.
| Name | Required | Description | Default |
|---|---|---|---|
| top | No | ||
| since | No | ||
| profile_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations supplied, the description carries the full behavioral burden and it partially covers it: it discloses ordering ('strongest links first') and that each result carries a ranking code plus a reason. It does not state that this is a read-only operation, how results are capped or paginated, or whether an empty profile yields an error versus an empty list. Adequate but with real gaps for a zero-annotation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with the ranking behavior front-loaded and the delegation hint second; nothing is padded. The clipped 'since: YYYY-MM-DD' fragment is efficient but reads as a note rather than prose, which slightly weakens the structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values needn't be described, and the description does note the per-item reason field that a caller will see. However, for a three-parameter tool with no annotations and no schema documentation, leaving `top` and the meaning of profile_id's 'subject' role unexplained is a meaningful omission.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for all three parameters. It explains the format of `since` (YYYY-MM-DD) and loosely identifies `profile_id` as 'the subject', but `top` — the result limit, defaulting to 10 — is never mentioned, leaving a caller to infer whether it is a count, a scope, or something else.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific resource and scope: stored news concerning a subject, ranked strongest-links-first with a reason per item. It also implicitly separates itself from analyze_news by naming that tool for follow-up depth. It stops short of a clean verb-led statement ('Which stored news concern the subject' is a fragment), but the retrieval purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives concrete routing guidance: use analyze_news on an event_id taken from this list to get full insight, which tells the agent this is the shallow discovery step and that tool is the depth step. It does not state exclusions (e.g. when to prefer list_events or search_research instead), so the when-not half of the guidance is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_researchC
Search the institution's research documents.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full behavioral burden, yet it says nothing about ranking, matching semantics, permissions, or result volume. The presence of an output schema covers return shape, but nothing about how search behaves is disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single clean sentence with no filler, so nothing is wasted, but the brevity comes at the cost of substance rather than from tight editing of a complete definition. It is under-specified rather than efficiently concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return values need not be described, but a search tool with no annotations, 0% parameter coverage, and no usage routing guidance leaves the agent guessing about both query semantics and when to invoke it. The definition does not do enough for a tool with two undocumented inputs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for two parameters, and the description does not compensate: it does not explain what a query string matches against (titles, bodies, authors) or that limit defaults to 3 and caps result count. Both parameters remain semantically opaque.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb (Search) and resource (the institution's research documents), which cleanly separates it from the news-, event-, and profile-oriented siblings. It stops short of explicitly contrasting with any named alternative, so it is clear but not maximally distinguishing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when this tool should be chosen over ask_followup, analyze_news, or other siblings, and no stated preconditions or exclusions. The agent must infer the use case entirely from the one-line purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
8 tool updates
v0.1.0- First observed
analyze_news - First observed
ask_followup - First observed
get_profile - First observed
get_trace - First observed
list_events - First observed
list_profiles - First observed
news_feed - First observed
search_research
TDQS
Scored across 8 tools
Most tools are distinct (analyze_news, ask_followup, get_trace, search_research), but news_feed and list_events both surface news items and their boundary is fuzzy — one ranks by relevance to a subject, the other returns latest events, and news_feed's description even references an ambiguous 'list'. An agent must read carefully to pick between them, and analyze_news's event_id input could come from either.
Seven of eight tools follow a verb_noun pattern (list_events, get_profile, analyze_news, ask_followup, get_trace, search_research, list_profiles), which is predictable and readable. news_feed is the single noun-style outlier, a minor deviation.
Eight tools is well-scoped for a news-analysis agent service: discovery (list_profiles, list_events, search_research), retrieval (get_profile, news_feed), analysis (analyze_news, ask_followup), and observability (get_trace). Each earns its place without padding.
Core workflow (find subject → find events → analyze → follow up → inspect trace) is covered, but there is no way to fetch a single event's details directly, and ask_followup is explicitly session-bound, so prior insights cannot be retrieved in later sessions. Read-only profiles and no event ingestion may be intentional, but the surface has notable gaps.
Maintenance
Related MCP Connectors
Machine-readable entity discovery with provenance, trust and verified source evidence.
Read-only cited financial datasets, bounded research queries and source diagnostics.
Real-time financial news & regulatory intelligence: cited search, fetch, summaries, collections.
GRIN-scored news for agents: discover by verdict, pull full analysis, traverse extraction graphs.
Related MCP Servers
AlicenseAqualityCmaintenanceEnables AI clients to query and analyze aggregated multi-platform trending news through natural language, offering tools for trend tracking, sentiment analysis, similarity search, and other news intelligence tasks.27GPL 3.0- AlicenseAqualityAmaintenanceLets MCP clients query financial news as structured, sourced statements and topics — searching by symbol, sector, theme, sentiment, importance and time range, and retrieving trending developments, topic detail, news-volume and sentiment series, and attention-screened symbols or sectors. It also exposes reference metadata such as the data window and known incidents.12MIT
- AlicenseNot gradedqualityCmaintenanceEnables users to run deep research, quick searches, and report writing, and to retrieve research sources and context through MCP-compatible clients.MIT

trendradar-mcpofficial
AlicenseNot gradedqualityBmaintenanceEnables AI clients to access aggregated multi-platform trending topics and RSS feeds, filter news by keywords, and perform natural-language analysis, sentiment insights, and trend prediction.GPL 3.0