The Epiphron DRTx® developer documentation server is an MCP server your assistant calls while it writes code: the developer guides, the API reference, the wire contract with every field number, and the shipped sample projects. Every answer names the page and section it came from.
Ask a general-purpose assistant to call an Epiphron operation and it will do what it always does with an API it has never seen: guess, fluently. On a platform where a field number is the wire format, a fluent guess is a defect that compiles.
Your assistant shouldn’t remember Epiphron. It should look it up, and show you where.
The server speaks the open Model Context Protocol over streamable HTTP. Register it once with the key Visus issues to your company, and your assistant decides on its own when to search, what to read and which sample to start from.
One command or one JSON entry, with your developer docs key.
“Write a Python client that logs in, runs request 57 and reads the results.”
The assistant searches, fetches sections, reads operations, types and samples.
Code comes back with the sections it was built from, so you can check it.
Claude Desktop, Copilot and Cursor take the same URL and header in their MCP configuration. Nothing to install, no certificate on your side.
Not a single “search the docs” box. The tools follow the questions a developer asks when building against Epiphron, and the assistant picks the right one itself.
The product map: documentation areas, which tool answers what, the release of the index and the rules every answer follows.
Ranked full-text search over one area or all of them, with snippets and ids to fetch.
The full text of one section, or a document’s table of contents.
One service operation: request and response messages with field numbers and CLR types, its description and the C# sample.
One message or enum of the wire contract: fields, wire numbers, formats, subtypes, enum members.
Code from the shipped samples: C# and Python clients, the demo integration components, the SQL Server CLR sample.
How to start a project for an area: what to reference, build notes, a minimal first program, what to read next.
“What are the fields of ExecuteUnattendedRequestRequest and their wire numbers?”
The same help pages installed with Epiphron and opened from the client’s Help, plus the API reference, the wire contract model and the sample projects, organised in nine areas.
Programs that talk to the Epiphron service: the gRPC contract, transport, login and session, requests and results.
Connectors to investment systems and data providers: the agent contract, lifecycle and packaging.
Components that supply the securities of a data request.
The expression language of data maps, and custom function libraries.
Fetching security data from a source of your own, and synthetic values.
Agents, tools, guardrails and provenance extractors for the AI / Research module.
Service settings, platform security, credentials, installers, the data dictionary, sizing.
The command-line tool, the Excel add-in, the Log Viewer, security id validators.
The user guides, in your users’ terms: data requests, translation, field mapping, reference data.
Release-pinned keys: a key can be pinned to the Epiphron release you run, so your assistant keeps reading that release’s documentation after the next one ships. Every answer states the release and build time of the index it came from.
A firm that trades real money reads the security section first, so here it is.
It executes nothing and has no connection to any Epiphron installation, database or customer data. Your assistant sends it search words and identifiers, never your source.
Design documents, code reviews and the source repository are not in it. An automated check at build time refuses any index that would contain them.
Each key is a signed token verified on every call, with an expiry and a release. One key per developer or team; a revoked key is refused within minutes.
TLS 1.2 or later, plain HTTP refused. Nothing to install and no certificate to manage on your side.
The server logs which tool was called, by which key, and how fast it answered. It does not log your search words or your assistant’s conversation.
A bounded number of calls per minute per key keeps a looping assistant from turning into a load test. A normal coding session stays far below it.
Before release the server is run against a set of real developer questions across every area, from “which operation gives me the session token?” to “show me a sample integration agent and the interface it implements”. For each one we check that every fact a correct answer needs can be reached through the tools, and that the known wrong turns are avoided. The field numbers it returns are not transcribed by hand: they come from the same wire contract model that the Epiphron build refuses to ship without.
benchmark developer questions with every needed fact retrievable
documentation areas, from client API to AI plug-ins
read-only tools, each answer cited by document and section
contract model, shared by the server and the release gate
Developer docs keys are issued by Visus Consulting to client and partner firms. Ask your Visus contact for one, and your assistant can be reading the Epiphron guides in minutes.
Powering Asset Managers with Tailored OMS Solutions
