This server provides paper-trading and risk-control capabilities via MCP tools, with no live order routing.
Generate mock GNN alpha signals for informational purposes only.
Read normalized synthetic market-data quotes.
Run deterministic pre-trade risk validation without submitting an order.
Submit paper-only orders after mandatory pre-trade risk checks.
Trip an irreversible risk circuit breaker to block new order attempts during incidents.
Click on "Install 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., "@QuantRisk Compute portfolio risk and show limit utilization"
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.
This project is a production-like paper-trading and risk orchestration platform designed around deterministic pre-trade validation, auditability, and fail-closed operational controls. It includes a browser dashboard, REST API, MCP tools, PostgreSQL persistence, Redis controls, and Docker deployment.
Safety posture: live order routing is disabled by default and hard-coded to paper mode. This repository is designed to support controlled paper trading and operational validation, not live broker execution.
MCP Client / Agent
|
v
FastMCP Server
|
+--> Risk Engine (VaR, drawdown, max position)
+--> Order State Machine (QUEUED -> VALIDATED -> APPROVED -> PAPER_FILLED)
+--> PostgreSQL persistence (orders, positions, audit_logs)
+--> Redis cache and token-bucket rate limiter
+--> FastAPI gateway (dashboard, REST API, /healthz, /metrics)
+--> Prometheus + Grafana observabilityRelated MCP server: trading-mcp-server
The FastAPI gateway serves the dashboard at http://localhost:8000/. The dashboard provides:
synthetic market state and order-book depth
risk evaluation before execution
paper-order submission
open positions and recent orders
immutable audit events
portfolio and circuit-breaker status
explicit PAPER MODE and FAIL-CLOSED safety indicators
The dashboard is intentionally a live paper-trading console, not a real-money trading interface.
The UI does not fabricate order results. It calls the FastAPI endpoints, which execute the risk engine and persist orders, positions, and audit events in PostgreSQL. Redis supplies rate limiting and alert publishing.
The market feed is intentionally synthetic and deterministic. A ticker produces a repeatable demonstration quote, depth, spread, and feature vector instead of connecting to an exchange. This keeps the demo safe and reproducible. Replacing _market_state() with a validated market-data adapter is the production integration boundary.
You can use the complete paper-trading application from the website without an MCP client:
Enter a ticker to inspect its market state.
Evaluate a BUY or SELL order against the risk controls.
Submit the order through guarded paper execution.
View the persisted order, position, and audit records.
Run a portfolio risk report.
Run a deterministic stress scenario.
Monitor the circuit breaker and system status.
MCP clients and the website are two interfaces over the same workflow skills. The website is the easiest human interface; MCP is the automation interface for agents.
The dashboard uses these HTTP endpoints:
Method | Endpoint | Purpose |
|
| Paper mode, portfolio, and breaker status |
|
| Synthetic market state |
|
| Evaluate ticker, side, and quantity |
|
| Validate and fill a paper order; requires |
|
| Recent persisted orders |
|
| Persisted paper positions |
|
| Recent risk and execution events |
|
| Operator-triggered trading pause |
|
| Discover available workflow skills |
|
| Run the portfolio risk-report skill |
|
| Run the portfolio stress-test skill |
Example PowerShell request:
$body = @{ ticker = "AAPL"; side = "BUY"; qty = 10 } | ConvertTo-Json
Invoke-RestMethod http://localhost:8000/api/orders/paper -Method Post `
-Headers @{ "X-Idempotency-Key" = "demo-aapl-order-001" } `
-ContentType "application/json" -Body $bodyEach order key is cached in Redis for 24 hours. Repeating the same key returns the original completed payload without re-running risk or filling another order. Execution also acquires lock:position:{ticker} with a 500ms deadline; if another worker holds that ticker lock, the API returns 409 Conflict and records distributed_lock_timeout in the audit log.
MCP tools are the machine-callable skills of this application. An MCP client or agent can discover and invoke them through the FastMCP server. They all use the same risk and order-control concepts as the dashboard API:
MCP tool | Skill |
| Inspect synthetic quote, depth, spread, and GNN features |
| Validate an order against position, VaR, drawdown, and rate limits |
| Create a queued order, apply controls, and paper-fill approved orders; accepts optional |
| Discover the available quant workflow skills |
| Summarize positions, exposure, limits, and breaker state |
| Project portfolio P&L under a deterministic price shock |
The same catalog is available to browser and API clients at:
GET /api/skillsExample skill-oriented agent flow:
1. list_skills
2. get_market_state("AAPL")
3. evaluate_risk("AAPL", "BUY", 10)
4. execute_trade("AAPL", "BUY", 10)
5. portfolio_risk_report()
6. stress_test_portfolio(-5)Skills are intentionally workflow-level capabilities, while tools remain the individual callable operations. Both entry points use the same fail-closed risk engine, order state machine, PostgreSQL records, Redis controls, and audit events.
The reusable skill pattern is:
request -> rate limit -> risk evaluation -> state transition -> persistence -> audit + alertYou can add future skills as new @mcp.tool() functions and corresponding REST routes, but they should call shared domain services rather than duplicate risk logic. Current higher-level skills include portfolio-risk reporting and scenario stress testing. Appropriate future skills include reconciliation checks, operator health summaries, and model-drift checks.
The order lifecycle is deliberately strict and fail-closed:
QUEUED -> VALIDATED -> APPROVED -> PAPER_FILLED
\-> REJECTED
VALIDATED -> REJECTED
APPROVED -> REJECTED
REJECTED -> * (terminal)
PAPER_FILLED -> * (terminal)Any invalid transition raises an explicit domain exception via OrderStateTransitionError.
The risk engine enforces:
max position size per asset
account-level VaR threshold
dynamic daily drawdown circuit breaker
audit-log immutability for rejected trades
Redis pub/sub alerting on risk breaches
If any limit is breached, the system writes the rejection event to audit_logs, rejects the order, and triggers the alert channel.
The project uses PostgreSQL + SQLAlchemy Async ORM. Core schema:
orders: id, ticker, side, qty, price, status, created_at, updated_at
positions: ticker, qty, avg_entry_price, unrealized_pnl
audit_logs: id, order_id, event_type, details (JSONB), timestamp
A SQL migration script is provided in migrations/001_init_schema.sql.
mcp_server.py: MCP tools and higher-level skills for market state, risk, execution, reporting, and stress testing
core/risk.py: deterministic risk engine and fail-closed breaker
core/cache.py: Redis-backed state and token-bucket limiter
core/db.py: Async SQLAlchemy session and table definitions
core/state_machine.py: order lifecycle enforcement
api/gateway.py: FastAPI dashboard, REST API, health, and Prometheus metrics endpoints
frontend/: responsive browser dashboard served by FastAPI
migrations/001_init_schema.sql: PostgreSQL schema migration
.github/workflows/ci.yml: automated tests, formatting, and lint checks
python -m venv .venv
source .venv/bin/activate # or .\.venv\Scripts\Activate.ps1 on Windows
python -m pip install -e .[dev]
cp .env.example .env
python -m uvicorn api.gateway:app --host 0.0.0.0 --port 8000Open the dashboard at http://localhost:8000/.
Local MCP runner:
python mcp_server.pypytest -q
black --check .
flake8 .The verified local integration flow is:
healthz -> market state -> paper order -> PostgreSQL order/position/audit recordsThe test suite covers state transitions, risk rejection, drawdown/VaR controls, Redis rate limiting, and database initialization.
The repository includes container health checks and a full local observability stack:
PostgreSQL
Redis
Prometheus
Grafana
trading-engine service
Run the full stack:
docker compose up --buildIf port 8000 is already used on your machine, choose another host port in PowerShell:
$env:APP_PORT = "8001"
docker compose up -d --buildThen open http://localhost:8001/.
For a detached deployment:
docker compose up -d --buildThen visit:
http://localhost:3000 (Grafana)
http://localhost:9090 (Prometheus)
Check the running stack:
Invoke-RestMethod http://localhost:8000/healthz | ConvertTo-JsonExpected health response includes:
{"status":"ok","database":true,"redis":true,"paper_mode":true}This design intentionally enforces the following:
paper-only execution by default
explicit validation before execution
immutable audit records for every risk decision
fail-closed circuit breaker for drawdown and VaR violations
Redis-backed rate limiting for order spam mitigation
structured telemetry for trade execution and risk rejection events
This project is production-oriented but still intentionally constrained to paper trading. It is resume-ready as a deployed portfolio application, but it is not a live brokerage system. Before any real-money integration, the next milestones are:
migrate from synthetic market data to a validated feed provider
add durable approvals and secrets management
enforce multi-party sign-off for live execution
replace process-local risk state with fully shared transactional state
add authentication, authorization, HTTPS, restricted CORS, and managed secrets
add broker execution, idempotency, reconciliation, and exchange-level controls
Never set a public demo to live mode. The intended public deployment is a paper-trading demonstration with protected infrastructure dependencies.
See docs/architecture.md, docs/operational-controls.md, and docs/threat-model.md.
Run the mock PyTorch GNN and return an alpha score. Informational only; never places an order.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | ||
| features | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden. It discloses two key traits: the model is a mock and the call has no order side effects. However, it omits details about return shape, errors, or feature-vector requirements, so disclosure is partial.
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 no filler. The core action and output are front-loaded, and the crucial safety clarification 'never places an order' is included without redundancy.
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 a simple two-parameter mock tool, the purpose and side-effect profile are clear, and an output schema exists so return-value details are not required. The only notable gap is the unexplained 'features' parameter, but overall the description is sufficiently complete for the tool's complexity.
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 description adds no meaning for either parameter. 'symbol' is weakly inferable from the name, but 'features' is entirely unexplained—no length, ordering, or normalization context. The description fails to compensate for the schema 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 a specific action ('Run'), the resource ('mock PyTorch GNN'), and the output ('alpha score'). It also explicitly distinguishes itself from order-placing siblings with 'never places an order', making its purpose unmistakable.
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?
The phrase 'Informational only; never places an order' gives a clear context and an explicit when-not-to-use boundary. It does not name alternative siblings like market_snapshot or specify when to prefer this one, but the informational intent is clearly conveyed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a normalized mock market-data quote.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the disclosure burden. 'Read' and 'mock' convey that this is a non-destructive, non-production data operation, which is useful. However, it does not explain normalization rules, whether the quote is current/last available, error behavior, or any other operational trait, and no annotations compensate.
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 a single, front-loaded sentence with no filler; every word contributes. It is appropriately short for a one-parameter read operation, though terse.
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 a one-parameter read tool with an output schema, the core call shape is clear, but there is no usage guidance, no caveats, and no explanation of the 'normalized' aspect. The missing usage context and parameter semantics leave the agent to guess when and how to invoke this over alternatives.
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 schema has one required parameter, 'symbol', with 0% description coverage, and the description adds no explicit parameter explanation. The phrase 'market-data quote' only weakly implies that symbol identifies the instrument. A format or example would be needed to reach the low-coverage compensation bar.
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 ('Read') and a specific resource ('normalized mock market-data quote'), so an agent can tell this is the market-data retrieval tool. Among siblings (generate_alpha_signal, validate_order, submit_paper_order, trip_risk_circuit_breaker), it uniquely reads a quote rather than generating, validating, submitting, or tripping something.
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?
The description gives no explicit condition for use, no exclusions, and no pointer to an alternative sibling. It only states what the tool does; the agent must infer when to pick it. No prerequisites or context are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Submit a paper-only order after mandatory pre-trade risk validation.
| Name | Required | Description | Default |
|---|---|---|---|
| side | Yes | ||
| symbol | Yes | ||
| quantity | Yes | ||
| limit_price | Yes | ||
| client_order_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry behavioral weight. It discloses that the order is paper-only and that prior risk validation is mandatory, which are useful traits. However, it does not explain failure behavior, required permissions, or side effects, so it only partially satisfies the burden.
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 a single, front-loaded sentence with no filler. Every part contributes meaning: 'submit', 'paper-only order', and the pre-trade validation requirement.
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?
Despite having an output schema, the tool is missing essential usage context: parameter semantics are completely undocumented and there are no annotations. The description provides a high-level workflow hint but is not sufficient for an agent to construct valid calls reliably.
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 description provides no meaning for any of the five required parameters. It does not compensate for the schema's lack of documentation, leaving the agent to guess valid values for side, quantity, limit_price, and client_order_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 description states a specific verb ('submit') and resource ('paper-only order'), and adds a key ordering constraint ('after mandatory pre-trade risk validation') that distinguishes it from sibling validation tools. This is a clear, non-tautological purpose statement.
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?
The phrase 'after mandatory pre-trade risk validation' gives the agent explicit context about when to invoke this tool relative to the validation workflow. It does not name alternatives or state when not to use it, but the precondition is clear enough for correct sequencing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Irreversibly block new order attempts in this process; use for an incident or anomaly.
| Name | Required | Description | Default |
|---|---|---|---|
| reason | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and it discloses three key traits: irreversibility, scope ('in this process'), and what it affects ('new order attempts'). It does not cover operational details like idempotency or whether pending orders are affected, hence not a 5.
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 tightly written sentence with no filler; the core action and trigger are front-loaded. Every word earns its place.
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 a one-parameter tool with an output schema, the description covers the essential what, scope, and when. The 'reason' parameter semantics and a bit more operational context are absent, but the tool is simple enough that the missing detail is minor.
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 schema has one required string 'reason' with 0% description coverage, and the description adds no parameter-level meaning. The name alone gives some clue, but the description was required to compensate for the schema gap and does not.
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?
States a specific verb ('block'), resource ('new order attempts'), and a critical modifier ('irreversibly'), plus the emergency context ('incident or anomaly'). This is clearly distinct from sibling tools like submit_paper_order or validate_order.
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?
Gives a clear trigger condition: 'use for an incident or anomaly.' It does not explicitly name when-not-to-use or alternatives, but the emergency context is sufficient to guide selection against the normal-flow siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run deterministic pre-trade risk checks without submitting an order.
| Name | Required | Description | Default |
|---|---|---|---|
| side | Yes | ||
| symbol | Yes | ||
| quantity | Yes | ||
| limit_price | Yes | ||
| client_order_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral transparency burden. It does add meaningful traits: 'deterministic' and 'without submitting an order,' which rule out randomness and order placement side effects. It doesn't disclose input requirements or failure behavior, but the core safety property is stated.
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 a single sentence with no filler. It front-loads the action and the key safety distinction, making it easy to parse quickly.
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?
A tool with five required parameters, no annotations, and 0% schema coverage needs more than a one-line description for correct invocation. While an output schema exists, it does not compensate for missing parameter semantics and unclear boundaries versus sibling risk tools.
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 description does not explain any of the five required parameters. The agent is left with only parameter names and no guidance on formats, allowed values, or meaning, so the description adds no parameter-level value.
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 uses a specific verb ('Run') with a clear resource ('pre-trade risk checks') and adds the key distinction 'without submitting an order.' This makes it easy to distinguish from order-submission siblings like submit_paper_order.
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?
The phrase 'without submitting an order' gives a clear context for when to use this tool: when validation is needed but execution is not. However, it does not explicitly name alternatives or state when not to use it, especially relative to trip_risk_circuit_breaker.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0generate_alpha_signalmarket_snapshotsubmit_paper_ordertrip_risk_circuit_breakervalidate_orderEach tool maps to a clearly distinct concern: signal generation, market data, pre-trade validation, paper order submission, and circuit breaking. There is no meaningful overlap or ambiguity between the tools.
Most tools follow a clear verb_noun pattern like generate_alpha_signal, validate_order, and submit_paper_order. The exception is market_snapshot, which is noun-only and breaks the otherwise consistent convention.
Five tools is a well-scoped size for a focused quant risk and paper trading server. Each tool serves a distinct step in the intended workflow without redundancy or bloat.
The core flow of generating a signal, validating an order, submitting a paper order, and tripping a breaker is covered. However, there is no way to query or cancel submitted paper orders, and no visibility into the circuit breaker state, leaving notable lifecycle gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Build, backtest, and deploy quantitative trading strategies from your AI agent.
Live multi-asset market data for AI agents with provenance, starter credits, x402, and examples.
No-KYC managed MCP for AI agents: sandboxed TypeScript trading SDK, isolated sub-accounts, futures.
Trade across 22+ exchanges and brokers from any MCP-capable AI agent, no install required.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/avnijainnn/QuantRisk'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
