Skip to main content
Glama
Epsom700

Quant Framework MCP Server

by Epsom700

Quant Framework

An open, pluggable framework for composable quantitative workflows. Start with FRED. Expand to anything.

Inspired by Karpathy's autoresearch — the same three-layer contract (immutable evaluator, agent sandbox, human direction), applied to quantitative finance as an extensible framework.

This is a framework — not a product. FRED is the hello-world connector. Everything else is an extension of the same pattern.


Prerequisites


Related MCP server: OpenFinClaw CLI

Installation

# Clone the repository
git clone <repo-url>
cd quant_framework

# Install all dependencies
uv sync

Configuration

Environment Variables

Create a .env file in the project root (or export directly):

# .env
FRED_API_KEY=your_api_key_here

Persona Config

Edit configs/persona.yaml to control which functions and connectors your MCP server exposes:

name: "Quant Research Agent"
description: "MCP server exposing quantitative research functions"
host: "127.0.0.1"
port: 8000

functions:
  - run_linear
  - run_random_forest
  - run_svr
  - run_xgboost
  - run_bayesian_ridge
  - run_hmm

connectors:
  - fred

Guardrails Config

Edit configs/guardrails.yaml to define validation rules for function outputs:

defaults:
  max_records: 10000

rules:
  run_linear:
    max_records: 5000
    required_fields: [model, r_squared, coefficients]
    roles:
      analyst:
        redacted_fields: [model]

Usage

CLI — Start the MCP Server

# Show available commands
uv run quant --help

# Start the MCP server with SSE transport
uv run quant serve --persona configs/persona.yaml

# Use stdio transport instead
uv run quant serve --persona configs/persona.yaml --transport stdio

This will:

  1. Register all modelling functions from the FunctionRegistry

  2. Initialise connectors (auto-connects using $FRED_API_KEY)

  3. Start the MCP server on 127.0.0.1:8000

Connect from Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "quant-framework": {
      "url": "http://localhost:8000/sse"
    }
  }
}

Run the Example Script

uv run python examples/basic_usage.py

This demonstrates:

  1. Querying GDP data from FRED

  2. Running linear regression via the FunctionRegistry

  3. Validating the result through the GuardrailEngine


Project Structure

quant_framework/
├── pyproject.toml                # Dependencies & CLI entry point
├── configs/
│   ├── persona.yaml              # MCP server persona config
│   └── guardrails.yaml           # Validation rules
├── examples/
│   └── basic_usage.py            # End-to-end demo script
├── experiments/                  # Autonomous research loop files
│   ├── evaluate.py               # Evaluation harness (scalar metric)
│   ├── prepare_snapshot.py       # Data snapshot caching script
│   └── strategy.py               # Editable strategy sandbox
├── program.md                    # Human-directed research agenda
└── quant_framework/              # Package root
    ├── cli.py                    # CLI (quant serve)
    ├── core/
    │   ├── function.py           # @register_function, FunctionRegistry, FunctionResult
    │   └── guardrail.py          # GuardrailEngine, GuardrailViolation
    ├── connectors/
    │   ├── connectors.py         # BaseConnector, ConnectorRegistry
    │   └── fred.py               # FREDConnector (with 24h file cache)
    ├── functions/
    │   └── modelling.py          # Registered modelling functions
    └── mcp/
        └── generator.py          # MCPServerGenerator

Core Components

Connectors

Connector

Registry Name

Description

FREDConnector

fred

Federal Reserve Economic Data with 24h file-based cache

from quant_framework.connectors import FREDConnector

fred = FREDConnector()
fred.connect({"api_key": "your_key"})
df = fred.query("GDP", observation_start="2020-01-01")

Modelling Functions

All functions are registered with @register_function and return a FunctionResult:

Function

Registry Name

Model Type

Key Outputs

run_linear_regression

run_linear

LinearRegression

coefficients, intercept, r²

run_random_forest

run_random_forest

RandomForestRegressor

feature_importances, r²

run_svr

run_svr

SVR

run_xgboost

run_xgboost

XGBRegressor

feature_importances, r²

run_bayesian_ridge

run_bayesian_ridge

BayesianRidge

posterior_std, alpha_, lambda_

run_hmm

run_hmm

GaussianHMM

hidden_states, transition_matrix, AIC, BIC

from quant_framework.functions.modelling import run_linear_regression

result = run_linear_regression(df, target="GDP", features=["UNRATE", "FEDFUNDS"])
print(result.output["r_squared"])   # 0.12
print(result.trace_id)              # unique trace ID

Guardrail Engine

from quant_framework.core import GuardrailEngine

engine = GuardrailEngine("configs/guardrails.yaml")
engine.validate("run_linear", result.output)           # passes
engine.validate("run_linear", result.output, role="analyst")  # applies role-specific rules
  • Hot-reload: edits to the YAML take effect immediately (checks file mtime)

  • Per-role overrides: stricter rules for specific roles

Function Registry

from quant_framework.core import FunctionRegistry

# List all registered functions
FunctionRegistry.list()                        # ['run_linear', 'run_random_forest', ...]
FunctionRegistry.list_by_category("modelling") # filter by category

# Call by name
result = FunctionRegistry.call("run_linear", df=df, target="GDP")

The Autonomous Research Loop

The framework includes a fully autonomous research loop designed to test hypotheses and incrementally improve a quantitative strategy.

It builds on the three-layer contract outlined in program.md:

  1. Fixed Evaluation Harness (experiments/evaluate.py): Scores the strategy on a fixed historical dataset.

  2. Strategy Sandbox (experiments/strategy.py): The single file where the agent tests features, model choices, and signal logic.

  3. Human Direction (program.md): Defines the agent's constraints and the high-level research agenda.

Running the Loop

Provide the program.md file to any autonomous coding agent (like Claude or the built-in system) and instruct it to begin. The agent will read program.md, modify experiments/strategy.py, run evaluate.py, and use a keep/discard ratchet to only commit changes that improve the composite score.


Extending the Framework

Add a Connector

from quant_framework.connectors.connectors import BaseConnector, ConnectorRegistry

@ConnectorRegistry.register("bloomberg")
class BloombergConnector(BaseConnector):
    def connect(self, config): ...
    def query(self, request, **kwargs): ...
    def get_schema(self): ...
    def health_check(self): ...

Add a Function

from quant_framework.core import register_function, FunctionResult

@register_function(name="my_indicator", category="technical")
def my_indicator(df, window=14):
    result = ...  # your logic
    return FunctionResult(output={"value": result}, metrics={"window": window})

The function is automatically available in the FunctionRegistry and can be exposed as an MCP tool by adding its name to your persona YAML.


Design Principles

  • Connector-first. Every data source is a BaseConnector. Learn one interface, connect anything.

  • Functions as atoms. Decorated Python functions that auto-register and auto-expose via MCP.

  • Progressive complexity. Start with FRED. Add what you need, when you need it.

  • Three-layer contract. Immutable evaluator (guardrails), agent sandbox (function store), human direction (persona configs).


Contributors

Arjun Singh

License

MIT

Available Tools

6 tools
run_bayesian_ridgeB

Fit a Bayesian Ridge Regression.

Returns standard regression outputs plus Bayesian-specific posterior standard deviations and estimated precision parameters (alpha, lambda).

ParametersJSON Schema
NameRequiredDescriptionDefault
kwargsYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

B3.1/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. Adequately discloses return behavior (standard outputs + Bayesian parameters), but omits computational characteristics, convergence criteria, memory requirements, or failure modes. Mentions alpha/lambda as estimated precision parameters, adding useful Bayesian context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Perfectly structured with two high-density sentences: action (line 1) and return value specification (line 2). No filler words; every term earns its place. Front-loaded with the operation type immediately stated.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having output schema, the description appropriately summarizes returns. However, severely incomplete due to undocumented 'kwargs' parameter—with 0% schema coverage, the description must specify input structure or regression arguments, leaving users without necessary invocation details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Critical failure: With 0% schema coverage and a single opaque 'kwargs' parameter, the description must explain expected arguments (features, targets, hyperparameters), but provides zero input guidance. Mentioning alpha/lambda as outputs doesn't help with inputs.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Excellent specificity: 'Fit a Bayesian Ridge Regression' provides clear verb+algorithm. Crucially distinguishes from siblings (run_linear, run_svr, etc.) by explicitly mentioning Bayesian-specific outputs (posterior standard deviations, precision parameters alpha/lambda) that unique identify this tool's probabilistic nature.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit when-to-use guidance or comparisons to alternatives. While the mention of Bayesian-specific outputs implies use for uncertainty quantification, there's no explicit guidance like 'use when you need probabilistic estimates vs point estimates from run_linear' or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run_hmmA

Fit a Gaussian Hidden Markov Model.

Unlike the regression functions, HMMs are unsupervised — there is no
target column.  The function discovers *n_states* hidden regimes in the
data and returns the decoded state sequence, transition matrix, and
per-state Gaussian parameters.
ParametersJSON Schema
NameRequiredDescriptionDefault
kwargsYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. Discloses key behaviors: discovers 'n_states hidden regimes', returns 'decoded state sequence, transition matrix, and per-state Gaussian parameters', and clarifies unsupervised nature. Lacks mention of convergence behavior or computational intensity, but covers core functionality well.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three efficient sentences with zero waste. First establishes tool identity, second distinguishes from siblings, third describes outputs. Information density is high with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Conceptually complete regarding HMM mechanics and outputs (though output schema exists, making some description redundant). However, the practical invocation is severely underdocumented due to the undocumented 'kwargs' parameter. Adequate but with clear gaps in input specification.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% coverage with a single opaque 'kwargs' parameter. Description mentions 'n_states' in passing (as *n_states*), providing minimal semantic context for what arguments might be expected, but fails to document the kwargs wrapper structure or enumerate available parameters. With 0% schema coverage, this compensation is insufficient.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clear verb 'Fit' with specific resource 'Gaussian Hidden Markov Model'. Explicitly distinguishes from siblings by contrasting with 'regression functions' in the second sentence, establishing this as the unsupervised alternative to the supervised regression tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use: 'unsupervised — there is no target column'. This directly contrasts with supervised siblings (run_linear, run_random_forest, etc.), providing clear selection criteria. The 'Unlike the regression functions' framing gives perfect when-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run_linearC

Fit a Linear Regression and return results with coefficients and residuals.

ParametersJSON Schema
NameRequiredDescriptionDefault
kwargsYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

C2.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description carries the full burden. It discloses that the tool returns 'coefficients and residuals,' hinting at the output structure and read-only analysis nature. However, it lacks details on computational complexity, convergence behavior, or memory requirements typical for model fitting operations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, front-loaded with the action verb, no redundant phrases. Appropriate brevity for the information provided.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having an output schema (covering return values), the tool description inadequately addresses the complexity of a statistical modeling operation. The opaque 'kwargs' parameter combined with lack of annotations leaves critical usage context undocumented.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage with a single opaque 'kwargs' parameter. The description fails to compensate by documenting expected arguments (features, target data, fit_intercept, etc.), making the tool essentially uninvokable without external documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description provides a specific verb ('Fit') and resource ('Linear Regression'), clearly identifying the statistical operation. However, it does not differentiate from sibling regression tools (run_bayesian_ridge, run_svr) regarding when linear regression is the appropriate choice.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance provided on when to use this tool versus alternatives like run_random_forest or run_xgboost. No prerequisites or data format requirements are mentioned, despite this being a statistical modeling operation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run_random_forestC

Fit a Random Forest Regressor and return results with feature importances.

ParametersJSON Schema
NameRequiredDescriptionDefault
kwargsYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

C2.7/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden. It discloses that results include 'feature importances' (useful behavioral detail), but fails to mention critical ML traits: randomness/stochastic behavior, expected input data structure (X/y), computational intensity, or training time implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence of 11 words is front-loaded with verb and resource. No redundancy or filler. However, given the severe lack of schema documentation, this brevity is insufficient rather than elegant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having an output schema (reducing need for return value description), the tool is severely incomplete due to the undocumented kwargs parameter and lack of behavioral context. For an ML training tool with 0% schema coverage and no annotations, the description must explain inputs, data format, and key hyperparameters—it provides none of these.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% (the single 'kwargs' parameter has no description or properties), and the description completely fails to compensate—it makes no mention of what kwargs accepts (e.g., n_estimators, max_depth, random_state) or what data inputs are required. For a single-parameter tool with opaque schema, this is a critical gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States specific action 'Fit' and resource 'Random Forest Regressor', and mentions 'feature importances' which distinguishes it from generic ML tools. However, it does not differentiate from siblings like run_xgboost or run_svr in terms of when to prefer this algorithm.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Contains no guidance on when to use Random Forest versus sibling alternatives (run_xgboost, run_svr, run_linear, etc.), nor any prerequisites like data format or train/test splits. Zero explicit or implicit usage guidance provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run_svrC

Fit a Support Vector Regressor and return results.

ParametersJSON Schema
NameRequiredDescriptionDefault
kwargsYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

C2.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It mentions fitting and returning results but omits computational cost, whether this caches models, expected kwargs structure, or side effects of the training process.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence of nine words is efficiently structured, but results in under-specification for a complex ML tool with opaque parameters. Every word earns its place, yet the brevity creates documentation gaps.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having an output schema (reducing description burden for returns), the tool critically lacks input documentation. For an ML training operation with completely undocumented kwargs, the description fails to explain data requirements, hyperparameter options, or model configuration.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% (the 'kwargs' parameter has no description). The description fails to compensate by documenting what keys/values are expected in kwargs (features, target, hyperparameters), leaving the single required parameter completely undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clear verb ('Fit') and resource ('Support Vector Regressor'), identifying this as a specific ML algorithm among siblings. However, it does not clarify when to choose SVR over alternatives like run_random_forest or run_xgboost.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance provided on when to use this regressor versus sibling algorithms (run_random_forest, run_xgboost, etc.) or prerequisites like data preprocessing needs.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run_xgboostB

Fit an XGBoost Regressor and return results with feature importances.

ParametersJSON Schema
NameRequiredDescriptionDefault
kwargsYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

B3/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full disclosure burden. It adds valuable behavioral context by specifying the tool returns 'feature importances' and identifies it as a 'Regressor' (not classifier). However, it omits other behavioral details like side effects, memory/computation constraints, or failure modes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficiently structured sentence with the action verb front-loaded. Every word earns its place with no redundancy or tautology.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having an output schema (which covers return values), the description inadequately documents inputs for this complex ML tool. With 0% input schema coverage, the opaque 'kwargs' parameter requires explanation that is completely absent, making the tool difficult to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% (the single 'kwargs' parameter has no description). The description fails to compensate by explaining what data or hyperparameters should be passed to this opaque parameter, though 'Fit' implies data is required. This is a significant gap for invoking the tool correctly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description provides a specific verb ('Fit') and resource ('XGBoost Regressor'), clearly identifying this as a model training tool. It distinguishes from siblings by naming the specific algorithm (XGBoost vs Random Forest, SVR, etc.), though it lacks explicit comparative guidance on selection criteria.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to select this tool versus sibling ML algorithms (run_random_forest, run_svr, etc.). It does not indicate appropriate use cases for XGBoost specifically or prerequisites like data format requirements.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

TDQS

B3.4/5.0
Disambiguation5/5

Every tool has a clearly distinct purpose with no ambiguity - each implements a different machine learning algorithm (Bayesian Ridge, HMM, Linear Regression, Random Forest, SVR, XGBoost). The descriptions clearly differentiate between supervised regression methods and the unsupervised HMM approach.

Naming Consistency5/5

Perfect naming consistency with all tools following the exact same 'run_algorithm' pattern. The naming convention is completely uniform across all six tools, making them easily predictable and readable.

Tool Count5/5

Six tools is well-scoped for a quant framework server focused on statistical modeling algorithms. Each tool earns its place by covering different modeling approaches (linear, tree-based, Bayesian, HMM, SVM, gradient boosting) without redundancy.

Completeness4/5

The toolset covers a comprehensive range of regression and time series modeling algorithms appropriate for quantitative analysis. Minor gaps might include clustering algorithms or additional preprocessing tools, but the core modeling surface is well-covered for a quant framework.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    MCP server that provides AI agents with financial tools including real-time quotes, backtesting, technical analysis, and multi-exchange data via a simple CLI interface.
    1
    MIT
  • A
    license
    B
    quality
    C
    maintenance
    An MCP server that provides economic intelligence using FRED data, including series search, metadata, observations, comparisons, and a curated macroeconomic knowledge graph with GraphRAG, digital twin simulation, and explainability.
    13
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Epsom700/quant_framework'

If you have feedback or need assistance with the MCP directory API, please join our Discord server