Quant Framework MCP Server
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., "@Quant Framework MCP ServerAnalyze US GDP data from FRED using a linear regression model"
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.
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
Python 3.12.10+
uv — Python package manager
FRED API Key — Get one free from FRED
Related MCP server: OpenFinClaw CLI
Installation
# Clone the repository
git clone <repo-url>
cd quant_framework
# Install all dependencies
uv syncConfiguration
Environment Variables
Create a .env file in the project root (or export directly):
# .env
FRED_API_KEY=your_api_key_herePersona 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:
- fredGuardrails 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 stdioThis will:
Register all modelling functions from the
FunctionRegistryInitialise connectors (auto-connects using
$FRED_API_KEY)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.pyThis demonstrates:
Querying GDP data from FRED
Running linear regression via the
FunctionRegistryValidating 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 # MCPServerGeneratorCore Components
Connectors
Connector | Registry Name | Description |
|
| 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 |
|
| LinearRegression | coefficients, intercept, r² |
|
| RandomForestRegressor | feature_importances, r² |
|
| SVR | r² |
|
| XGBRegressor | feature_importances, r² |
|
| BayesianRidge | posterior_std, alpha_, lambda_ |
|
| 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 IDGuardrail 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 rulesHot-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:
Fixed Evaluation Harness (
experiments/evaluate.py): Scores the strategy on a fixed historical dataset.Strategy Sandbox (
experiments/strategy.py): The single file where the agent tests features, model choices, and signal logic.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 toolsrun_bayesian_ridgeB
Fit a Bayesian Ridge Regression.
Returns standard regression outputs plus Bayesian-specific posterior standard deviations and estimated precision parameters (alpha, lambda).
| Name | Required | Description | Default |
|---|---|---|---|
| kwargs | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.| Name | Required | Description | Default |
|---|---|---|---|
| kwargs | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| kwargs | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| kwargs | 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 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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| kwargs | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| kwargs | 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 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.
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.
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.
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.
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.
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
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.
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.
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.
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
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
Research-only MCP server: turn your AI into a quant research desk — backtests, no trades.
The financial MCP for AI agents - 90+ financial tables, SEC filings, signals, alt-data.
Real SEC, 13F, insider, congress & macro data your AI agent can cite. Hosted MCP, 24 tools.
MCP server exposing the Backtest360 engine API as tools for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that provides AI agents with financial tools including real-time quotes, backtesting, technical analysis, and multi-exchange data via a simple CLI interface.1MIT
- FlicenseNot gradedqualityDmaintenanceEnables quant research, strategy generation, backtesting, and paper trading from natural language prompts, integrating with AI agents via an MCP server.63
- FlicenseNot gradedqualityDmaintenanceMCP server that exposes stock research tools (fundamentals, news, technicals, analyst ratings) to AI clients, enabling autonomous generation of structured investment briefs.
- AlicenseBqualityCmaintenanceAn 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.13MIT
Appeared in Searches
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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