content large_stringlengths 3 20.5k | url large_stringlengths 54 193 | branch large_stringclasses 4
values | source large_stringclasses 42
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
input, such as a string, integer, or boolean. When you request a scalar type, FastMCP automatically wraps it in an object schema for MCP spec compatibility. Clients will see a schema requesting a single "value" field of the requested type. Once clients respond, the provided object is "unwrapped" and the scalar value is... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/elicitation.mdx | main | model-context-protocol-fastmcp | [
-0.06862695515155792,
0.00531878974288702,
0.017996618524193764,
0.09220705181360245,
-0.06048930808901787,
-0.030842354521155357,
0.07411416620016098,
-0.003091360442340374,
-0.026494057849049568,
-0.10575137287378311,
0.04717196896672249,
-0.11708956956863403,
0.014677661471068859,
0.021... | 0.020398 |
```python @mcp.tool async def select\_priorities(ctx: Context) -> str: result = await ctx.elicit( "Choose priorities", response\_type=[{ "low": {"title": "Low Priority"}, "medium": {"title": "Medium Priority"}, "high": {"title": "High Priority"} }] ) if result.action == "accept": return f"Selected: {', '.join(result.da... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/elicitation.mdx | main | model-context-protocol-fastmcp | [
-0.012077988125383854,
0.024954214692115784,
0.05790276080369949,
0.048753511160612106,
-0.058598581701517105,
-0.06852391362190247,
-0.004025000147521496,
0.026292933151125908,
-0.020125018432736397,
0.016951680183410645,
-0.011644626036286354,
-0.038103844970464706,
0.00824024248868227,
... | -0.002401 |
import { VersionBadge } from '/snippets/version-badge.mdx' Components can be dynamically enabled or disabled at runtime. A disabled tool disappears from listings and cannot be called. This enables runtime access control, feature flags, and context-aware component exposure. ## Component Visibility Every FastMCP server p... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/visibility.mdx | main | model-context-protocol-fastmcp | [
-0.05814488232135773,
0.01930924318730831,
0.00444529065862298,
0.059203244745731354,
0.05393591523170471,
0.006606470327824354,
0.03235381096601486,
-0.05017334967851639,
-0.08203674852848053,
-0.06289003789424896,
0.07721246033906937,
0.06952481716871262,
0.09593265503644943,
-0.04504706... | -0.029816 |
the later disable() overrides the allowlist ``` You can always re-enable something that was disabled by adding another `enable()` call after it. ## Server vs Provider Visibility state operates at two levels: the server and individual providers. ### Server-Level Server-level visibility state applies to all components fr... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/visibility.mdx | main | model-context-protocol-fastmcp | [
-0.08021576702594757,
0.02545906975865364,
0.047557055950164795,
0.05603178218007088,
0.06422454863786697,
-0.04851989075541496,
-0.008035662584006786,
-0.065034881234169,
-0.07132541388273239,
-0.05986996740102768,
0.09357567131519318,
0.05658228322863579,
0.012824987061321735,
-0.0177040... | -0.02851 |
| |-----------|-------------| | `names` | Component names or URIs to match | | `keys` | Component keys (e.g., `{"tool:my\_tool"}`) | | `tags` | Tags to match (component must have at least one) | | `version` | Version specification to match | | `components` | Component types (`{"tool"}`, `{"resource"}`, `{"prompt"}`, `{... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/visibility.mdx | main | model-context-protocol-fastmcp | [
0.0001757766294758767,
0.027481278404593468,
0.04523252695798874,
-0.006635663565248251,
0.026562204584479332,
-0.004389731679111719,
0.01268635131418705,
-0.012434512376785278,
-0.04996143653988838,
-0.06117825582623482,
0.04697138071060181,
-0.06727869063615799,
0.07637748122215271,
-0.0... | -0.120345 |
names={"secret\_tool"})) ``` Server-level transforms override provider-level transforms. If a component is disabled at the provider level but enabled at the server level, the server-level `enable()` can re-enable it. | https://github.com/jlowin/fastmcp/blob/main//docs/servers/visibility.mdx | main | model-context-protocol-fastmcp | [
-0.10664503276348114,
-0.007313975133001804,
-0.02665630355477333,
0.05532575398683548,
-0.017917465418577194,
0.016022641211748123,
-0.04089817777276039,
-0.07805155962705612,
-0.03617066517472267,
-0.03552037850022316,
0.06851282715797424,
0.09672517329454422,
-0.012799677439033985,
0.05... | 0.003281 |
import { VersionBadge } from "/snippets/version-badge.mdx" Prompts are reusable message templates that help LLMs generate structured, purposeful responses. FastMCP simplifies defining these templates, primarily using the `@mcp.prompt` decorator. ## What Are Prompts? Prompts provide parameterized message templates for L... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
-0.005110468249768019,
0.029999950900673866,
0.062484823167324066,
-0.0645395815372467,
0.05386718362569809,
-0.015335864387452602,
0.008611621335148811,
0.015505705028772354,
-0.01358499750494957,
-0.043107736855745316,
0.009161757305264473,
-0.03265628218650818,
0.1342620700597763,
-0.06... | 0.011676 |
version identifier for this prompt. See [Versioning](/servers/versioning) for details. #### Using with Methods For decorating instance or class methods, use the standalone `@prompt` decorator and register the bound method. See [Tools: Using with Methods](/servers/tools#using-with-methods) for the pattern. ### Argument ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
-0.02986946329474449,
0.07897672057151794,
0.05780482292175293,
-0.02463226020336151,
-0.01191809680312872,
-0.06427153199911118,
0.012542949989438057,
0.03243055194616318,
-0.02218792773783207,
-0.017127200961112976,
0.0029590653721243143,
-0.04294294863939285,
0.028178155422210693,
0.008... | 0.085948 |
directly. Other types (dict, list, BaseModel) are automatically JSON-serialized. The message role. #### PromptResult `PromptResult` gives you explicit control over prompt responses: multiple messages, roles, and metadata at both the message and result level. ```python from fastmcp import FastMCP from fastmcp.prompts im... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
0.001833108952268958,
0.0346481017768383,
-0.014424772001802921,
0.04928546026349068,
-0.017722316086292267,
-0.04585859552025795,
0.03448465093970299,
0.035895511507987976,
-0.0316283255815506,
-0.05925893411040306,
0.044169891625642776,
-0.06182026490569115,
0.05178263410925865,
0.015416... | 0.045898 |
### Accessing MCP Context Prompts can access additional MCP information and features through the `Context` object. To access it, add a parameter to your prompt function with a type annotation of `Context`: ```python {6} from fastmcp import FastMCP, Context mcp = FastMCP(name="PromptServer") @mcp.prompt async def genera... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
-0.05068812146782875,
0.0210484080016613,
-0.05031070485711098,
0.07347293943166733,
-0.0036898485850542784,
-0.016974950209259987,
0.08698569983243942,
0.06410691887140274,
0.000944225350394845,
-0.01398157887160778,
-0.012228565290570259,
-0.04716305807232857,
0.09368132054805756,
-0.007... | 0.081991 |
import { VersionBadge } from '/snippets/version-badge.mdx' When a server exposes many tools, resources, or prompts, returning them all in a single response can be impractical. MCP supports pagination for list operations, allowing servers to return results in manageable chunks that clients can fetch incrementally. ## Se... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/pagination.mdx | main | model-context-protocol-fastmcp | [
-0.0423654168844223,
0.02119293622672558,
0.001702518085949123,
0.026602046564221382,
-0.04016813635826111,
-0.03667137026786804,
-0.036322709172964096,
-0.04988358914852142,
-0.02127191424369812,
0.021608231589198112,
0.022403081879019737,
0.06362060457468033,
0.10563682019710541,
-0.0788... | -0.025157 |
import { VersionBadge } from "/snippets/version-badge.mdx" LLM sampling allows your MCP tools to request text generation from an LLM during execution. This enables tools to leverage AI capabilities for analysis, generation, reasoning, and more—without the client needing to orchestrate multiple calls. By default, sampli... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.05553726479411125,
0.0371883362531662,
-0.024410804733633995,
0.017544278874993324,
0.042455725371837616,
-0.028767475858330727,
-0.0005419834051281214,
0.021511606872081757,
0.0219431109726429,
-0.03732401132583618,
-0.010082734748721123,
-0.056297965347766876,
0.09653320908546448,
-0.... | 0.032431 |
is optional—some clients may not implement it. To ensure your tools work regardless of client capabilities, configure a `sampling\_handler` that sends requests directly to an LLM provider. FastMCP provides built-in handlers for [OpenAI and Anthropic APIs](/clients/sampling#built-in-handlers). These handlers support the... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.07644437253475189,
-0.051140885800123215,
-0.00284961867146194,
0.02369093708693981,
0.02075040712952614,
-0.10743705928325653,
0.026434822008013725,
0.004638484213501215,
0.0071397810243070126,
-0.02993013896048069,
-0.001619346672669053,
-0.04777787998318672,
0.016796359792351723,
-0.... | 0.039264 |
str: """Search the web for information.""" return f"Results for: {query}" def get\_time() -> str: """Get the current time.""" from datetime import datetime return datetime.now().strftime("%H:%M:%S") mcp = FastMCP() @mcp.tool async def research(question: str, ctx: Context) -> str: """Answer questions using available too... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.05434204265475273,
0.07755599170923233,
-0.05465809255838394,
0.06130864471197128,
0.004041092935949564,
-0.08485106378793716,
-0.005529492627829313,
0.08782150596380234,
0.03419879451394081,
-0.06464177370071411,
0.014472665265202522,
-0.033096905797719955,
0.020480627194046974,
-0.059... | 0.058834 |
if the LLM requested tool calls | | `step.tool\_calls` | List of tool calls requested (if any) | | `step.text` | The text content (if any) | | `step.history` | All messages exchanged so far | The contents of `step.history` depend on `execute\_tools`: - \*\*`execute\_tools=True`\*\* (default): Includes tool results, rea... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.0869651660323143,
0.027653738856315613,
-0.02750345692038536,
0.055936772376298904,
-0.04052445665001869,
-0.0627385601401329,
-0.008580985479056835,
0.026460282504558563,
-0.0035553500056266785,
-0.04838815703988075,
0.030761683359742165,
-0.040061742067337036,
0.054965998977422714,
-0... | -0.007995 |
import { VersionBadge } from "/snippets/version-badge.mdx" The `FastMCP` class is the central piece of every FastMCP application. It acts as the container for your tools, resources, and prompts, managing communication with MCP clients and orchestrating the entire server lifecycle. ## Creating a Server Instantiate a ser... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/server.mdx | main | model-context-protocol-fastmcp | [
-0.061880387365818024,
0.009619315154850483,
0.0006063178298063576,
-0.023232704028487206,
-0.03191129118204117,
-0.0933978483080864,
0.026779333129525185,
0.018597422167658806,
-0.009831473231315613,
-0.02275874651968479,
0.029354257509112358,
0.006361417006701231,
0.08009155839681625,
-0... | 0.119821 |
ID.""" return {"id": user\_id, "name": f"User {user\_id}", "status": "active"} ``` See [Resource Templates](/servers/resources#resource-templates) for detailed documentation. ### Prompts Prompts are reusable message templates that guide LLM interactions. They help establish consistent patterns for how clients should fr... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/server.mdx | main | model-context-protocol-fastmcp | [
-0.006618670653551817,
0.09635460376739502,
-0.05204278603196144,
0.025460412725806236,
0.007874824106693268,
-0.10167669504880905,
0.12398646771907806,
0.03811695799231529,
-0.005920883268117905,
-0.017647147178649902,
0.01934223435819149,
-0.013154315762221813,
0.08657015115022659,
-0.01... | 0.101874 |
import { VersionBadge } from '/snippets/version-badge.mdx' Progress reporting allows MCP tools to notify clients about the progress of long-running operations. Clients can display progress indicators and provide better user experience during time-consuming tasks. ## Basic Usage Use `ctx.report\_progress()` to send prog... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/progress.mdx | main | model-context-protocol-fastmcp | [
-0.05844438448548317,
0.05950799956917763,
0.003184693632647395,
0.03783458471298218,
-0.001989210257306695,
-0.0200818981975317,
-0.001182087347842753,
-0.00910918228328228,
-0.025776084512472153,
-0.024068007245659828,
-0.008297847583889961,
-0.010546012781560421,
0.05407628417015076,
-0... | 0.065048 |
FastMCP includes native OpenTelemetry instrumentation for observability. Traces are automatically generated for tool, prompt, resource, and resource template operations, providing visibility into server behavior, request handling, and provider delegation chains. ## How It Works FastMCP uses the OpenTelemetry API for in... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/telemetry.mdx | main | model-context-protocol-fastmcp | [
-0.07784857600927353,
0.0019616198260337114,
0.0011312286369502544,
0.018885865807533264,
0.04880893602967262,
-0.13278290629386902,
-0.0014297848101705313,
-0.032961901277303696,
0.05455750226974487,
-0.003975242841988802,
0.05305054783821106,
-0.08665279299020767,
-0.010381406173110008,
... | 0.114099 |
complex\_operation(input: str) -> str: tracer = get\_tracer() with tracer.start\_as\_current\_span("parse\_input") as span: span.set\_attribute("input.length", len(input)) parsed = parse(input) with tracer.start\_as\_current\_span("process\_data") as span: span.set\_attribute("data.count", len(parsed)) result = process... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/telemetry.mdx | main | model-context-protocol-fastmcp | [
-0.010917975567281246,
0.0340212918817997,
0.008056974038481712,
0.08533499389886856,
-0.02013785019516945,
-0.08616039901971817,
0.013071288354694843,
0.058951471000909805,
-0.014483386650681496,
-0.03512636944651604,
0.03141811862587929,
-0.02091633342206478,
0.08540764451026917,
-0.0384... | 0.046628 |
import { VersionBadge } from '/snippets/version-badge.mdx' This documentation covers \*\*MCP client logging\*\*—sending messages from your server to MCP clients. For standard server-side logging (e.g., writing to files, console), use `fastmcp.utilities.logging.get\_logger()` or Python's built-in `logging` module. Serve... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/logging.mdx | main | model-context-protocol-fastmcp | [
-0.018203720450401306,
0.03015977144241333,
0.012437675148248672,
0.0031565092504024506,
0.06953185796737671,
-0.09295865148305893,
0.02904592640697956,
-0.0003670910664368421,
-0.021377436816692352,
0.0017304269131273031,
0.0241744052618742,
-0.011125818826258183,
0.07173670828342438,
-0.... | 0.022572 |
import { VersionBadge } from '/snippets/version-badge.mdx' Component versioning lets you maintain multiple implementations of the same tool, resource, or prompt under a single identifier. You register each version, and FastMCP handles the rest: clients see the highest version by default, but you can filter to expose ex... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/versioning.mdx | main | model-context-protocol-fastmcp | [
-0.03037738800048828,
-0.009375124238431454,
0.039650432765483856,
-0.05592583119869232,
0.027165066450834274,
-0.04605460166931152,
-0.06818996369838715,
-0.031273920089006424,
-0.03872291371226311,
-0.026557667180895805,
0.0034966361708939075,
-0.004713583737611771,
0.08485105633735657,
... | -0.071262 |
def process(data: str, mode: str = "default") -> str: """Enhanced processing with mode selection.""" if mode == "reverse": return data[::-1].upper() return data.upper() ``` Both versions are registered. When a client lists tools, they see only `process` with version 2.0 (the highest). When they invoke `process`, versio... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/versioning.mdx | main | model-context-protocol-fastmcp | [
-0.05031001940369606,
-0.0058371867053210735,
0.02992750145494938,
-0.016536055132746696,
-0.04394317418336868,
-0.09718862175941467,
-0.05496678128838539,
0.018043436110019684,
-0.0026205049362033606,
-0.001275974209420383,
0.06532106548547745,
-0.038566701114177704,
0.048897452652454376,
... | -0.063188 |
you asked for rather than silently falling back to a different version. ### MCP Protocol For generic MCP clients that don't have built-in version support, pass the version through the `\_meta` field in arguments. FastMCP servers extract the version from `\_meta.fastmcp.version` before processing. ```json Tool Call Argu... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/versioning.mdx | main | model-context-protocol-fastmcp | [
0.018571410328149796,
0.05670030415058136,
0.10476558655500412,
0.013191960752010345,
0.066661037504673,
-0.005378305912017822,
-0.05744490027427673,
0.02390264719724655,
0.0026974459178745747,
-0.05589281767606735,
0.008340795524418354,
-0.002958114957436919,
-0.05692126601934433,
0.03182... | -0.068795 |
"""Updated implementation with new options parameter.""" return modern\_process(input, options or {}) ``` Clients automatically see version 2.0 (the highest). During the transition, your server code can still access the original implementation via `get\_tool("process\_data", version="1.0")`. Once the migration is compl... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/versioning.mdx | main | model-context-protocol-fastmcp | [
-0.02264798991382122,
-0.021688081324100494,
0.04587450250983238,
-0.04498491808772087,
0.04254884272813797,
-0.10529762506484985,
-0.0747547522187233,
-0.02943081222474575,
-0.053962789475917816,
0.015249067917466164,
0.036728497594594955,
0.06993328034877777,
-0.0376027375459671,
-0.0093... | -0.046322 |
import { VersionBadge } from "/snippets/version-badge.mdx" Middleware adds behavior that applies across multiple operations—authentication, logging, rate limiting, or request transformation—without modifying individual tools or resources. MCP middleware is a FastMCP-specific concept and is not part of the official MCP ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.08027826249599457,
-0.023861827328801155,
0.09599553793668747,
-0.08549246937036514,
0.0937773585319519,
-0.07937268167734146,
-0.06731599569320679,
-0.027415035292506218,
0.008574508130550385,
0.03841826319694519,
-0.021077841520309448,
0.027601266279816628,
0.07756736129522324,
-0.049... | 0.113873 |
|-----------|------|-------------| | `method` | `str` | MCP method name (e.g., `"tools/call"`) | | `source` | `str` | Origin: `"client"` or `"server"` | | `type` | `str` | Message type: `"request"` or `"notification"` | | `message` | `object` | The MCP message data | | `timestamp` | `datetime` | When the request was re... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.09674540907144547,
-0.015777166932821274,
0.009250917471945286,
0.0697890892624855,
0.01855182647705078,
-0.12407976388931274,
0.03908112272620201,
0.030574187636375427,
0.003573100082576275,
-0.041112020611763,
0.03538570925593376,
-0.033628661185503006,
0.024309150874614716,
0.0066617... | 0.108797 |
dispatch system entirely. Use when you need uniform handling regardless of message type. ### Session Availability The MCP session may not be available during certain phases like initialization. Check before accessing session-specific attributes: ```python async def on\_request(self, context: MiddlewareContext, call\_ne... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.09759704023599625,
0.027783889323472977,
0.031960371881723404,
0.009353921748697758,
-0.03329088166356087,
-0.10481707006692886,
0.01124882698059082,
0.018272796645760536,
-0.025220071896910667,
0.008512360043823719,
0.0035041356459259987,
-0.02287955954670906,
0.001902302261441946,
0.0... | 0.116954 |
Default | Description | |-----------|------|---------|-------------| | `include\_traceback` | `bool` | `False` | Include stack traces in logs | | `transform\_errors` | `bool` | `False` | Convert exceptions to MCP errors | | `error\_callback` | `Callable` | `None` | Custom callback on errors | For automatic retries: ```... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.09779568761587143,
-0.018435940146446228,
0.013409638777375221,
0.014156819321215153,
-0.002287259791046381,
-0.10698339343070984,
0.00621442124247551,
0.0074262130074203014,
-0.012698694132268429,
0.026694132015109062,
0.04446746036410332,
0.01574084348976612,
0.06713544577360153,
-0.0... | 0.11859 |
reach the client. When filtering list results, also block execution in the corresponding operation hook to maintain consistency: ```python from fastmcp.server.middleware import Middleware, MiddlewareContext from fastmcp.exceptions import ToolError class PrivateToolFilter(Middleware): async def on\_list\_tools(self, con... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.08226949721574783,
0.023372182622551918,
-0.005008442793041468,
0.02767518162727356,
0.08980831503868103,
-0.07648024708032608,
0.029798755422234535,
0.01308438554406166,
0.009485187008976936,
-0.06229846179485321,
0.04627903178334236,
-0.05364479124546051,
0.035416655242443085,
-0.0340... | -0.002785 |
import { VersionBadge } from "/snippets/version-badge.mdx" Authorization controls what authenticated users can do with your FastMCP server. While [authentication](/servers/auth/authentication) verifies identity (who you are), authorization determines access (what you can do). FastMCP provides a callable-based authoriza... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/authorization.mdx | main | model-context-protocol-fastmcp | [
-0.02960362657904625,
0.048253871500492096,
-0.031068792566657066,
-0.07894649356603622,
0.05108693987131119,
-0.04592561721801758,
0.051384009420871735,
-0.016673417761921883,
-0.007703318726271391,
-0.04859566316008568,
0.03448048606514931,
-0.0038974250201135874,
0.07225031405687332,
-0... | 0.046865 |
minimum\_level return check @mcp.tool(auth=require\_premium\_user) def premium\_feature() -> str: """Only for premium users.""" return "Premium content" @mcp.tool(auth=require\_access\_level(5)) def advanced\_feature() -> str: """Requires access level 5 or higher.""" return "Advanced feature" ``` Auth checks can raise ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/authorization.mdx | main | model-context-protocol-fastmcp | [
-0.07123982161283493,
0.07861261814832687,
0.023259537294507027,
0.023433269932866096,
0.06924156844615936,
-0.07296087592840195,
0.07180555164813995,
-0.0023827804252505302,
-0.036789774894714355,
-0.0031747967004776,
0.10163408517837524,
-0.07681262493133545,
0.11262053996324539,
0.00062... | -0.008388 |
Description | |----------|------|-------------| | `token` | `str` | The raw token string | | `client\_id` | `str \| None` | OAuth client identifier | | `scopes` | `list[str]` | Granted OAuth scopes | | `expires\_at` | `datetime \| None` | Token expiration time | | `claims` | `dict[str, Any]` | All JWT claims or custom ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/authorization.mdx | main | model-context-protocol-fastmcp | [
-0.08794976025819778,
0.0568084791302681,
-0.03289737179875374,
0.042002495378255844,
0.02073393203318119,
-0.024827126413583755,
0.07453050464391708,
0.0540781207382679,
-0.007273279130458832,
-0.023986363783478737,
0.003452087752521038,
-0.06754686683416367,
0.06882881373167038,
-0.03130... | 0.055198 |
import { VersionBadge } from "/snippets/version-badge.mdx" Resources represent data or files that an MCP client can read, and resource templates extend this concept by allowing clients to request dynamically generated resources based on parameters passed in the URI. FastMCP simplifies defining both static and dynamic r... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.057151373475790024,
0.03513983264565468,
0.027311375364661217,
-0.014961098320782185,
0.02787473052740097,
-0.0701151043176651,
0.002246919786557555,
-0.017208334058523178,
0.03237064555287361,
-0.06788165867328644,
-0.010164942592382431,
0.05025699734687805,
0.10137699544429779,
-0.045... | 0.05909 |
identifier for this resource. See [Versioning](/servers/versioning) for details. #### Using with Methods For decorating instance or class methods, use the standalone `@resource` decorator and register the bound method. See [Tools: Using with Methods](/servers/tools#using-with-methods) for the pattern. ### Return Values... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.043721117079257965,
0.05069475620985031,
-0.046155285090208054,
0.03866597265005112,
0.03332383558154106,
-0.1112198755145073,
0.01898493804037571,
0.02898697927594185,
0.005213093478232622,
0.030012376606464386,
-0.034823980182409286,
-0.009343267418444157,
0.041140347719192505,
0.0098... | 0.039284 |
FastMCP supports both `async def` and regular `def` resource functions. Synchronous functions automatically run in a threadpool to avoid blocking the event loop. For I/O-bound operations, async functions are more efficient: ```python import aiofiles from fastmcp import FastMCP mcp = FastMCP(name="DataServer") @mcp.reso... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.04026518389582634,
0.0030808225274086,
-0.015466916374862194,
0.05603581294417381,
0.03061842732131481,
-0.11427192389965057,
0.04643073305487633,
0.05721025541424751,
0.04574264585971832,
-0.0016055741580203176,
0.0223088376224041,
0.027981167659163475,
-0.021857207641005516,
0.0036516... | 0.042855 |
metadata to your resources through annotations. These annotations communicate how resources behave to client applications without consuming token context in LLM prompts. Annotations serve several purposes in client applications: - Indicating whether resources are read-only or may have side effects - Describing the safe... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.046389419585466385,
0.06721249967813492,
0.0009787284070625901,
0.02673930674791336,
0.04837855324149132,
-0.0596744641661644,
0.03205983713269234,
0.05775633454322815,
0.011894014663994312,
-0.04257290065288544,
-0.030174843966960907,
-0.029531355947256088,
0.08242394775152206,
-0.0170... | 0.073243 |
multiple path segments. While standard parameters (`{param}`) only match a single path segment and don't cross "/" boundaries, wildcard parameters (`{param\*}`) can capture multiple segments including slashes. Wildcards capture all subsequent path segments \*up until\* the defined part of the URI template (whether lite... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.04906785115599632,
0.06355805695056915,
0.05079122260212898,
0.01992524228990078,
-0.024362022057175636,
-0.02658231183886528,
-0.006165188271552324,
0.038123343139886856,
-0.018095288425683975,
-0.056585703045129776,
0.02217959798872471,
-0.0426286943256855,
0.055389951914548874,
0.013... | -0.013551 |
these validation rules when creating resource templates: 1. \*\*Required function parameters\*\* (no default values) must appear in the URI path template 2. \*\*Query parameters\*\* (specified with `{?param}` syntax) must be optional function parameters with default values 3. \*\*All URI template parameters\*\* (path a... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.12365194410085678,
0.08920517563819885,
0.001367855235002935,
-0.02442232333123684,
-0.05345683544874191,
-0.04833916947245598,
0.021842356771230698,
-0.01728435605764389,
-0.042170748114585876,
-0.049116089940071106,
-0.01574741117656231,
-0.03937513753771782,
0.0494033508002758,
0.035... | 0.005771 |
def get\_config\_v1(): return {"version": 1} # This registration attempt will raise a ValueError because # "data://config" is already registered and the behavior is "error". # @mcp.resource("data://config") # def get\_config\_v2(): return {"version": 2} ``` The duplicate behavior options are: - `"warn"` (default): Logs... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.08776288479566574,
-0.018472202122211456,
0.07860841602087021,
0.022469112649559975,
0.06647301465272903,
-0.08200660347938538,
-0.017657216638326645,
-0.013792832382023335,
-0.038988690823316574,
-0.04339835047721863,
0.06368051469326019,
0.026299944147467613,
0.04618635028600693,
-0.0... | 0.002351 |
import { VersionBadge } from "/snippets/version-badge.mdx"; FastMCP uses dependency injection to provide runtime values to your tools, resources, and prompts. Instead of passing context through every layer of your code, you declare what you need as parameter defaults—FastMCP resolves them automatically when your functi... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/dependency-injection.mdx | main | model-context-protocol-fastmcp | [
-0.044110916554927826,
0.05324835702776909,
0.06713943928480148,
-0.020716944709420204,
0.04185323789715767,
-0.04299995303153992,
0.032515235245227814,
0.0244594793766737,
-0.05075399950146675,
-0.03452511876821518,
-0.013081831857562065,
-0.07939081639051437,
0.02580001763999462,
-0.0006... | 0.013049 |
``` Both raise `RuntimeError` when called outside an HTTP context (e.g., STDIO transport). Use HTTP Headers if you need graceful fallback. ### HTTP Headers Access HTTP headers with graceful fallback—returns an empty dictionary when no HTTP request is available, making it safe for code that might run over any transport.... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/dependency-injection.mdx | main | model-context-protocol-fastmcp | [
-0.10602712631225586,
0.09241195768117905,
-0.018220290541648865,
0.0159309022128582,
0.0012964403722435236,
-0.08720844238996506,
0.012842212803661823,
0.006712544243782759,
-0.032337695360183716,
-0.048168450593948364,
0.07198072224855423,
-0.056164465844631195,
0.07970605045557022,
-0.0... | -0.008493 |
users=Depends(get\_user\_repo), orders=Depends(get\_order\_repo), ) -> str: # Both repos share the same db connection return f"Processed order {order\_id}" ``` ### Resource Management For dependencies that need cleanup—database connections, file handles, HTTP clients—use an async context manager. The cleanup code runs ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/dependency-injection.mdx | main | model-context-protocol-fastmcp | [
-0.0793612077832222,
-0.030197033658623695,
-0.035142555832862854,
0.069683738052845,
-0.05978644639253616,
-0.08578839153051376,
0.043238792568445206,
-0.05378729850053787,
-0.024858683347702026,
-0.012391602620482445,
0.07559018582105637,
0.007308410946279764,
0.06270124763250351,
-0.073... | -0.047698 |
import { VersionBadge } from '/snippets/version-badge.mdx' Icons provide visual representations for your MCP servers and components, helping client applications present better user interfaces. When displayed in MCP clients, icons help users quickly identify and navigate your server's capabilities. ## Icon Format Icons ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/icons.mdx | main | model-context-protocol-fastmcp | [
-0.029945911839604378,
0.06596789509057999,
0.0637500062584877,
0.0050298296846449375,
0.056268032640218735,
-0.052117738872766495,
0.007443767506629229,
-0.0054286178201437,
0.002631185809150338,
-0.0365147702395916,
-0.019477544352412224,
0.05059872567653656,
0.07453979551792145,
-0.0329... | 0.034978 |
import { VersionBadge } from '/snippets/version-badge.mdx' When defining FastMCP [tools](/servers/tools), [resources](/servers/resources), resource templates, or [prompts](/servers/prompts), your functions might need to interact with the underlying MCP session or access advanced server capabilities. FastMCP provides th... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.06790954619646072,
0.03958410769701004,
0.028289837762713432,
-0.009104362688958645,
0.07398073375225067,
-0.031279802322387695,
0.024136284366250038,
0.0004235355299897492,
-0.05041748657822609,
-0.01917172223329544,
0.0332689993083477,
-0.02748800814151764,
0.08171331137418747,
-0.051... | 0.076062 |
get\_context mcp = FastMCP(name="Dependency Demo") # Utility function that needs context but doesn't receive it as a parameter async def process\_data(data: list[float]) -> dict: # Get the active context - only works when called within a request ctx = get\_context() await ctx.info(f"Processing {len(data)} data points")... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.11294253915548325,
0.01485797856003046,
-0.04247474670410156,
0.07238496094942093,
-0.0003988824028056115,
-0.14582385122776031,
0.09420779347419739,
0.0168788880109787,
-0.03487446531653404,
-0.06234018877148628,
0.05654500052332878,
-0.06508693099021912,
0.009005650877952576,
-0.03262... | 0.059228 |
have their own counter. \*\*Method signatures:\*\* - \*\*`await ctx.set\_state(key: str, value: Any) -> None`\*\*: Store a value in session state - \*\*`await ctx.get\_state(key: str) -> Any`\*\*: Retrieve a value (returns None if not found) - \*\*`await ctx.delete\_state(key: str) -> None`\*\*: Remove a value from ses... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.08109337091445923,
0.034472785890102386,
-0.09661972522735596,
0.07273134589195251,
-0.06451871246099472,
-0.053179167211055756,
0.01909300498664379,
0.033198121935129166,
0.02305816486477852,
0.03436337783932686,
0.043537408113479614,
-0.010548124089837074,
0.05125763267278671,
-0.0267... | 0.152495 |
the ID of the client making the request, if provided during initialization - \*\*`ctx.session\_id -> str`\*\*: Get the MCP session ID for session-based data sharing. Raises `RuntimeError` if the MCP session is not yet established. #### Request Context Availability The `ctx.request\_context` property provides access to ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.10480642318725586,
0.043611377477645874,
0.01075289398431778,
-0.015017895959317684,
0.0048724147491157055,
-0.10975069552659988,
0.0628088042140007,
0.028267400339245796,
0.013346192426979542,
-0.01520844828337431,
-0.01675400137901306,
0.010240493342280388,
0.02701571211218834,
-0.022... | 0.072218 |
import { VersionBadge } from '/snippets/version-badge.mdx' Lifespans let you run code once when the server starts and clean up when it stops. Unlike per-session handlers, lifespans run exactly once regardless of how many clients connect. ## Basic Usage Use the `@lifespan` decorator to define a lifespan: ```python from ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/lifespan.mdx | main | model-context-protocol-fastmcp | [
-0.08235489577054977,
0.03192425146698952,
0.013952589593827724,
0.013850482180714607,
0.021579328924417496,
-0.0753689780831337,
-0.0318390317261219,
-0.02515849843621254,
0.033389076590538025,
0.01886489987373352,
0.04107532277703285,
0.0431862398982048,
0.06047505512833595,
-0.037015944... | 0.020648 |
import { VersionBadge } from "/snippets/version-badge.mdx" \*\*This is an extremely advanced pattern that most users should avoid.\*\* Building a secure OAuth 2.1 server requires deep expertise in authentication protocols, cryptography, and security best practices. The complexity extends far beyond initial implementati... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/full-oauth-server.mdx | main | model-context-protocol-fastmcp | [
-0.08759089559316635,
0.04681473225355148,
0.0688086673617363,
-0.08078969269990921,
0.05633637681603432,
-0.024186773225665092,
0.0278365109115839,
-0.010602976195514202,
-0.019644541665911674,
-0.04779613018035889,
0.030716730281710625,
0.013430061750113964,
0.10522464662790298,
-0.01894... | -0.03141 |
and secure storage requirements. Mistakes can lead to serious security vulnerabilities. | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/full-oauth-server.mdx | main | model-context-protocol-fastmcp | [
-0.03163127601146698,
0.051518529653549194,
-0.019501252099871635,
0.011205284856259823,
0.005335947033017874,
-0.0370149165391922,
-0.07525215297937393,
0.017966603860259056,
0.0269094780087471,
0.015080387704074383,
0.047138214111328125,
0.11936715990304947,
0.0621325746178627,
0.0180553... | 0.125497 |
import { VersionBadge } from "/snippets/version-badge.mdx" Authentication in MCP presents unique challenges that differ from traditional web applications. MCP clients need to discover authentication requirements automatically, negotiate OAuth flows without user intervention, and work seamlessly across different identit... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/authentication.mdx | main | model-context-protocol-fastmcp | [
-0.06427313387393951,
0.02683107927441597,
0.013052948750555515,
-0.08180637657642365,
0.03553567826747894,
-0.036663834005594254,
0.04674891382455826,
-0.0010762620950117707,
-0.029609590768814087,
-0.024248016998171806,
0.015118024311959743,
-0.03148461505770683,
0.07267110794782639,
-0.... | 0.098439 |
authentication features without the complexity of building them from scratch. It scales well across multiple applications and provides consistent user experiences. ### Full OAuth Implementation Your server implements a complete OAuth 2.0 authorization server, handling everything from user credential verification to tok... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/authentication.mdx | main | model-context-protocol-fastmcp | [
-0.09534643590450287,
0.02263275347650051,
0.06874414533376694,
-0.04380127415060997,
0.03922641649842262,
-0.04972148314118385,
0.001519613666459918,
0.01118057407438755,
0.01858684979379177,
-0.022797875106334686,
-0.00017000841035041958,
-0.01842314936220646,
0.044506948441267014,
-0.01... | 0.06573 |
providers require manual app registration and fixed credentials, `OAuthProxy` bridges the gap. It presents a DCR-compliant interface to MCP clients (accepting any registration request) while using your pre-registered credentials with the upstream provider. The proxy handles the complexity of callback forwarding, enabli... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/authentication.mdx | main | model-context-protocol-fastmcp | [
-0.15991361439228058,
-0.011239620856940746,
-0.0002689796965569258,
0.010951231233775616,
-0.030883770436048508,
-0.06914222985506058,
-0.05147920176386833,
0.06790145486593246,
-0.007779317442327738,
-0.0728016346693039,
0.01402709074318409,
0.02687172405421734,
0.08937706798315048,
-0.0... | -0.04149 |
designed for, providing the best user experience and simplest implementation. \*\*Token validation works well when you already have authentication infrastructure that issues structured tokens.\*\* If your organization already uses JWT-based systems, API gateways, or enterprise SSO that can generate tokens, this approac... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/authentication.mdx | main | model-context-protocol-fastmcp | [
-0.10670450329780579,
-0.0006943197804503143,
0.08418571203947067,
-0.0383138582110405,
0.03572596609592438,
-0.02049451321363449,
0.021837806329131126,
0.022989356890320778,
0.03261689841747284,
-0.04340940713882446,
-0.014520901255309582,
-0.00005801040606456809,
0.06093321740627289,
-0.... | 0.156353 |
import { VersionBadge } from "/snippets/version-badge.mdx"; The OIDC proxy enables FastMCP servers to authenticate with OIDC providers that \*\*don't support Dynamic Client Registration (DCR)\*\* out of the box. This includes OAuth providers like: Auth0, Google, Azure, AWS, etc. For providers that do support DCR (like ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oidc-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.13685257732868195,
0.01969294436275959,
0.0018374945502728224,
-0.022751566022634506,
0.02355903759598732,
-0.03995624557137489,
0.007712384685873985,
-0.03358164802193642,
0.01982307806611061,
-0.02674839273095131,
0.006892837584018707,
0.0415337048470974,
0.07837199419736862,
-0.03501... | -0.075918 |
clients. Accepts any string or bytes - will be derived into a proper 32-byte cryptographic key using HKDF. \*\*Default behavior (`None`):\*\* - \*\*Mac/Windows\*\*: Auto-managed via system keyring. Keys are generated once and persisted, surviving server restarts with zero configuration. Keys are automatically derived f... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oidc-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.04778634011745453,
-0.0027112364768981934,
-0.037571750581264496,
-0.016359291970729828,
-0.027439137920737267,
0.002981877652928233,
0.06790769100189209,
0.05382305383682251,
0.0725431963801384,
0.0295136496424675,
0.03582293167710304,
-0.005938548594713211,
0.06754820048809052,
0.0214... | 0.076934 |
import { VersionBadge } from "/snippets/version-badge.mdx"; The OAuth proxy enables FastMCP servers to authenticate with OAuth providers that \*\*don't support Dynamic Client Registration (DCR)\*\*. This includes virtually all traditional OAuth providers: GitHub, Google, Azure, AWS, Discord, Facebook, and most enterpri... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.12669405341148376,
-0.01842081919312477,
0.06984301656484604,
-0.04665679112076759,
0.03084099479019642,
-0.025938397273421288,
-0.022002017125487328,
-0.006257536355406046,
0.05243484675884247,
-0.012060016393661499,
-0.0030915087554603815,
0.05054241418838501,
0.09027444571256638,
-0.... | -0.047258 |
the redirect URI configured in your OAuth application Optional URL of provider's token revocation endpoint Issuer URL for OAuth authorization server metadata (defaults to `base\_url`). When `issuer\_url` has a path component (either explicitly or by defaulting from `base\_url`), FastMCP creates path-aware discovery rou... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.02529849298298359,
-0.006086460314691067,
0.019327258691191673,
0.031140221282839775,
-0.020734282210469246,
-0.09991399198770523,
-0.05320844426751137,
0.007568186614662409,
0.04431429132819176,
-0.05613023042678833,
0.03509709984064102,
0.043525759130716324,
0.05491255968809128,
0.003... | -0.035904 |
a JWT Signing Key or your own client\_storage. For production deployments with multiple servers or cloud deployments, see [Storage Backends](/servers/storage-backends) for available options. \*\*When providing custom storage\*\*, wrap it in `FernetEncryptionWrapper` to encrypt sensitive OAuth tokens at rest: ```python ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.044683437794446945,
0.021504804491996765,
-0.08724237978458405,
0.021981678903102875,
0.0020282345358282328,
-0.10058017820119858,
0.011563943699002266,
0.07988472282886505,
0.057073477655649185,
-0.030544688925147057,
-0.03519259765744209,
-0.01511331181973219,
0.048301298171281815,
-0... | 0.05237 |
verifiers like `GitHubTokenVerifier` See the [Token Verification guide](/servers/auth/token-verification) for detailed setup instructions for your provider. ### Scope Configuration OAuth scopes control what permissions your application requests from users. They're configured through your `TokenVerifier` (required for t... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.07940267026424408,
-0.008894802071154118,
0.009709573350846767,
0.029590381309390068,
-0.026599476113915443,
-0.1293180286884308,
0.03265061974525452,
0.06491471827030182,
-0.023573245853185654,
-0.06967687606811523,
-0.07681803405284882,
0.004456704948097467,
0.11014045774936676,
0.018... | 0.019044 |
receive the provider's tokens. The proxy validates the client's PKCE verifier before returning the stored tokens. This entire flow is transparent to the MCP client—it experiences a standard OAuth flow with dynamic registration, unaware that a proxy is managing the complexity behind the scenes. ### Token Architecture Th... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.132908895611763,
-0.001829142333008349,
0.10850180685520172,
-0.00013382230827119201,
0.009259337559342384,
-0.04778868705034256,
0.05326106399297714,
0.0003780433034989983,
0.040528230369091034,
-0.045532193034887314,
-0.042960185557603836,
0.04369919374585152,
0.0701071247458458,
-0.0... | 0.007843 |
(random salt at startup). Storage defaults to memory. Tokens become invalid on server restart. \*\*For production:\*\* Configure the following parameters together: provide a unique `jwt\_signing\_key` (for signing FastMCP JWTs), and a shared `client\_storage` backend (for storing tokens). Both are required for producti... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.06807538121938705,
0.03675228729844093,
0.016679812222719193,
-0.010769219137728214,
0.039548903703689575,
-0.058862943202257156,
0.0555972121655941,
0.057889651507139206,
0.06717536598443985,
-0.026019008830189705,
0.004793328233063221,
-0.0016872582491487265,
0.09175913035869598,
0.01... | 0.06112 |
import { VersionBadge } from "/snippets/version-badge.mdx" Token verification enables your FastMCP server to validate bearer tokens issued by external systems without participating in user authentication flows. Your server acts as a pure resource server, focusing on token validation and authorization decisions while de... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/token-verification.mdx | main | model-context-protocol-fastmcp | [
-0.07521554082632065,
-0.00025766598992049694,
0.09099684655666351,
-0.061077047139406204,
0.08670754730701447,
-0.05220187082886696,
0.056699488312006,
-0.055068258196115494,
0.05747239664196968,
0.006187762133777142,
0.01196020282804966,
0.010815794579684734,
0.10767531394958496,
0.00743... | 0.091051 |
techniques and claim validation. ### JWKS Endpoint Integration JWKS endpoint integration provides the most flexible approach for production systems. The verifier automatically fetches public keys from a JSON Web Key Set endpoint, enabling automatic key rotation without server configuration changes. ```python from fastm... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/token-verification.mdx | main | model-context-protocol-fastmcp | [
-0.15705539286136627,
0.0449114553630352,
-0.005068669561296701,
-0.04893486201763153,
-0.00708637572824955,
-0.09724998474121094,
-0.015805289149284363,
-0.016084086149930954,
0.03478870168328285,
-0.013211041688919067,
0.03814345598220825,
-0.033563267439603806,
0.09843796491622925,
-0.0... | 0.03333 |
opaque token validation through OAuth 2.0 Token Introspection (RFC 7662). ### Understanding Opaque Tokens Opaque tokens differ fundamentally from JWTs in their verification model. Where JWTs carry signed claims that can be validated locally, opaque tokens require network calls to the issuing authorization server for va... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/token-verification.mdx | main | model-context-protocol-fastmcp | [
-0.0998813584446907,
0.05892125889658928,
0.05685490742325783,
-0.011991258710622787,
0.05379582196474075,
-0.155723437666893,
0.03908943012356758,
-0.00042239733738824725,
0.09083832055330276,
-0.08460771292448044,
-0.023549944162368774,
0.026414021849632263,
0.03023350238800049,
-0.04017... | 0.139576 |
For more controlled testing, provide custom validation logic: ```python from fastmcp.server.auth.providers.debug import DebugTokenVerifier # Synchronous validation - check token prefix verifier = DebugTokenVerifier( validate=lambda token: token.startswith("dev-"), client\_id="development-client", scopes=["read", "write... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/token-verification.mdx | main | model-context-protocol-fastmcp | [
-0.09590635448694229,
-0.03687334060668945,
-0.05638071522116661,
0.028002647683024406,
-0.04428680241107941,
-0.1284821778535843,
-0.009313140995800495,
-0.023285193368792534,
0.008771910332143307,
-0.014898409135639668,
0.02835753746330738,
-0.019124623388051987,
0.0820261761546135,
-0.0... | 0.033929 |
import { VersionBadge } from "/snippets/version-badge.mdx" Remote OAuth integration allows your FastMCP server to leverage external identity providers that \*\*support Dynamic Client Registration (DCR)\*\*. With DCR, MCP clients can automatically register themselves with the identity provider and obtain credentials wit... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/remote-oauth.mdx | main | model-context-protocol-fastmcp | [
-0.13257698714733124,
0.009907810017466545,
0.03935577720403671,
-0.041215017437934875,
0.05280807241797447,
0.0037266600411385298,
0.010927211493253708,
0.0008923286222852767,
0.02319270744919777,
-0.006278460379689932,
0.013942105695605278,
0.025172417983412743,
0.0820167064666748,
-0.02... | -0.013551 |
FastMCPServer->>FastMCPServer: 6. Verify token signature FastMCPServer-->>Client: 7. MCP response ``` This flow separates concerns cleanly: your MCP server handles resource protection and token validation, while your identity provider handles user authentication and token issuance. The client coordinates between these ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/remote-oauth.mdx | main | model-context-protocol-fastmcp | [
-0.12967070937156677,
0.005179826635867357,
0.07122830301523209,
-0.02806679531931877,
0.07785053551197052,
-0.03627951443195343,
0.02166386879980564,
0.003180714091286063,
0.04928084462881088,
-0.01849931851029396,
0.05843702703714371,
0.02399510331451893,
0.07524062693119049,
-0.01068035... | 0.025414 |
token\_verifier = JWTVerifier( jwks\_uri="https://auth.yourcompany.com/.well-known/jwks.json", issuer="https://auth.yourcompany.com", audience="mcp-production-api" ) super().\_\_init\_\_( token\_verifier=token\_verifier, authorization\_servers=[AnyHttpUrl("https://auth.yourcompany.com")], base\_url="https://api.yourcom... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/auth/remote-oauth.mdx | main | model-context-protocol-fastmcp | [
-0.07542303204536438,
0.03227976709604263,
-0.0033609161619096994,
0.0020025931298732758,
0.013027395121753216,
-0.07709057629108429,
-0.019950993359088898,
0.021689390763640404,
-0.05080036446452141,
-0.017016859725117683,
-0.032209016382694244,
-0.06069829687476158,
0.03336530923843384,
... | -0.000708 |
import { VersionBadge } from '/snippets/version-badge.mdx' Every FastMCP server has one or more component providers. A provider is a source of tools, resources, and prompts - it's what makes components available to clients. ## What Is a Provider? When a client connects to your server and asks "what tools do you have?",... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/overview.mdx | main | model-context-protocol-fastmcp | [
-0.03578275069594383,
-0.021277083083987236,
0.0685473084449768,
0.00211455044336617,
0.05264491215348244,
0.013805629685521126,
0.0004131349560339004,
-0.03693313151597977,
-0.0089870635420084,
-0.012355630286037922,
0.03718079626560211,
-0.019055644050240517,
0.08011328428983688,
-0.0525... | -0.049074 |
[Mount another server](/servers/providers/mounting) into yours - [Proxy a remote server](/servers/providers/proxy) through yours - [Control visibility state](/servers/visibility) of components - [Build dynamic sources](/servers/providers/custom) like database-backed tools ## Next Steps - [Local](/servers/providers/loca... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/overview.mdx | main | model-context-protocol-fastmcp | [
-0.06647823750972748,
-0.02826249971985817,
-0.038865894079208374,
0.02729995734989643,
-0.05188242718577385,
-0.04634655639529228,
-0.007335820700973272,
-0.02350223995745182,
-0.06780771911144257,
0.02720797248184681,
-0.0017995847156271338,
0.006748070940375328,
0.04707036539912224,
-0.... | 0.029855 |
import { VersionBadge } from '/snippets/version-badge.mdx' `FileSystemProvider` scans a directory for Python files and automatically registers functions decorated with `@tool`, `@resource`, or `@prompt`. This enables a file-based organization pattern similar to Next.js routing, where your project structure becomes your... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/filesystem.mdx | main | model-context-protocol-fastmcp | [
-0.13230422139167786,
-0.004765968304127455,
-0.003931502345949411,
0.007995842956006527,
0.07260838896036148,
-0.037471089512109756,
-0.03868694230914116,
0.008155697956681252,
0.04564262926578522,
0.016382357105612755,
0.04401005432009697,
0.08314359933137894,
0.0443570651113987,
0.02472... | 0.02512 |
and analogies." ``` The decorator supports: `name`, `title`, `description`, `icons`, `tags`, and `meta`. ## Directory Structure The directory structure is purely organizational. The provider recursively scans all `.py` files regardless of which subdirectory they're in. Subdirectories like `tools/`, `resources/`, and `p... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/filesystem.mdx | main | model-context-protocol-fastmcp | [
-0.07232678681612015,
-0.007730849087238312,
-0.027451129630208015,
0.044539675116539,
-0.002311027841642499,
-0.10523896664381027,
0.04104766249656677,
0.02792726457118988,
-0.04839735105633736,
0.014082499779760838,
0.02252890169620514,
0.03301546722650528,
0.08794263750314713,
0.0877445... | 0.034105 |
import { VersionBadge } from '/snippets/version-badge.mdx' Custom providers let you source components from anywhere - databases, APIs, configuration systems, or dynamic runtime logic. If you can write Python code to fetch or generate a component, you can wrap it in a provider. ## When to Build Custom The built-in provi... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/custom.mdx | main | model-context-protocol-fastmcp | [
-0.05542683228850365,
-0.05984976142644882,
-0.03184224292635918,
0.006980573758482933,
0.019216440618038177,
-0.0073742615059018135,
-0.023797154426574707,
0.012238842435181141,
-0.06321264803409576,
0.0030790846794843674,
0.0011433092877268791,
0.00819697417318821,
0.048278361558914185,
... | 0.022919 |
```python from collections.abc import Callable, Sequence from fastmcp import FastMCP from fastmcp.server.providers import Provider from fastmcp.tools import Tool class DictProvider(Provider): def \_\_init\_\_(self, tools: dict[str, Callable]): super().\_\_init\_\_() self.\_tools = [ Tool.from\_function(fn, name=name) f... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/custom.mdx | main | model-context-protocol-fastmcp | [
-0.13144011795520782,
-0.013513551093637943,
-0.055212292820215225,
0.0012464052997529507,
-0.15593573451042175,
-0.0894341915845871,
0.06741302460432053,
-0.002574177458882332,
0.013213120400905609,
-0.03949317708611488,
0.06667649000883102,
-0.03781711682677269,
0.02730000950396061,
0.02... | -0.016085 |
import { VersionBadge } from '/snippets/version-badge.mdx' Agent skills are directories containing instructions and supporting files that teach an AI assistant how to perform specific tasks. Tools like Claude Code, Cursor, and VS Code Copilot each have their own skills directories where users can add custom capabilitie... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/skills.mdx | main | model-context-protocol-fastmcp | [
-0.07611880451440811,
-0.03204100951552391,
-0.0326920785009861,
-0.05215063691139221,
0.012587988749146461,
0.049191880971193314,
0.040112413465976715,
0.018288221210241318,
-0.08874672651290894,
-0.03942827507853508,
-0.027524573728442192,
0.02635033056139946,
0.06542317569255829,
0.0203... | 0.087264 |
files, and creates the appropriate resources. ```python from pathlib import Path from fastmcp import FastMCP from fastmcp.server.providers.skills import SkillProvider mcp = FastMCP("Single Skill") mcp.add\_provider(SkillProvider(Path.home() / ".claude" / "skills" / "pdf-processing")) ``` Use `SkillProvider` when you wa... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/skills.mdx | main | model-context-protocol-fastmcp | [
-0.046655863523483276,
-0.05097830668091774,
-0.08951332420110703,
0.02260013483464718,
0.0017368944827467203,
-0.03145170956850052,
0.03909486159682274,
0.03315897658467293,
-0.05217276141047478,
-0.061478141695261,
0.09794814139604568,
0.042016834020614624,
0.06559993326663971,
0.0626805... | 0.002318 |
removed skills disappear, and modified content reflects current file state. Reload mode adds overhead to every request. Use it during development when you're actively editing skills, but disable it in production. ## Client Utilities FastMCP provides utilities for downloading skills from any MCP server that exposes them... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/skills.mdx | main | model-context-protocol-fastmcp | [
-0.0519949235022068,
0.026419535279273987,
-0.009004022926092148,
0.10114584863185883,
0.02478894591331482,
-0.028605856001377106,
0.02430272474884987,
-0.028478533029556274,
-0.03630746155977249,
-0.004060631617903709,
0.04348379373550415,
0.09536559879779816,
0.009739699773490429,
-0.028... | 0.014224 |
import { VersionBadge } from '/snippets/version-badge.mdx' Mounting lets you combine multiple FastMCP servers into one. When you mount a server, all its components become available through the parent. Under the hood, FastMCP uses `FastMCPProvider` (v3.0.0+) to source components from the mounted server. ## Why Mount Ser... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/mounting.mdx | main | model-context-protocol-fastmcp | [
-0.039102956652641296,
-0.024268845096230507,
0.030844273045659065,
-0.024805495515465736,
0.027492860332131386,
-0.10878147929906845,
-0.05939982831478119,
0.0021883994340896606,
-0.03426330164074898,
-0.0021531444508582354,
0.03471069782972336,
-0.009892817586660385,
0.0998716726899147,
... | -0.012525 |
mount() creates a live link ``` ### Static Importing With `import\_server()`, components are copied once at import time: ```python main = FastMCP("Main") async def setup(): await main.import\_server(static\_server, namespace="static") # Changes to static\_server after this point are NOT reflected in main ``` ## Direct ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/mounting.mdx | main | model-context-protocol-fastmcp | [
-0.10020273178815842,
-0.038330402225255966,
0.01396878995001316,
0.03575997054576874,
-0.02226339839398861,
-0.11995281279087067,
-0.07606412470340729,
-0.0019143500830978155,
-0.002198688453063369,
0.005407814402133226,
0.05863470584154129,
0.07554011046886444,
0.05851658433675766,
0.029... | -0.005638 |
import { VersionBadge } from '/snippets/version-badge.mdx' `LocalProvider` stores components that you define directly on your server. When you use `@mcp.tool`, `@mcp.resource`, or `@mcp.prompt`, you're adding components to your server's `LocalProvider`. ## How It Works Every FastMCP server has a `LocalProvider` as its ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/local.mdx | main | model-context-protocol-fastmcp | [
-0.03709559887647629,
-0.0023516297806054354,
0.0556410551071167,
0.008805599994957447,
0.03849705681204796,
-0.001587339793331921,
0.006509922910481691,
-0.029024362564086914,
0.017483554780483246,
-0.02956273779273033,
0.08051659911870956,
0.0007987964781932533,
0.07416096329689026,
-0.0... | -0.060431 |
import { VersionBadge } from '/snippets/version-badge.mdx' The Proxy Provider sources components from another MCP server through a client connection. This lets you expose any MCP server's tools, resources, and prompts through your own server, whether the source is local or accessed over the network. ## Why Use Proxy Pr... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/proxy.mdx | main | model-context-protocol-fastmcp | [
-0.04564674198627472,
-0.012464003637433052,
0.04990877956151962,
-0.06351874768733978,
-0.029106328263878822,
-0.013297632336616516,
-0.027722055092453957,
-0.014303440228104591,
-0.020274629816412926,
0.004907215945422649,
-0.03234885260462761,
-0.015593161806464195,
0.06868356466293335,
... | 0.06111 |
config = { "mcpServers": { "default": { "url": "https://example.com/mcp", "transport": "http" } } } proxy = create\_proxy(config, name="Config-Based Proxy") ``` ### Multi-Server Proxies Combine multiple servers with automatic namespacing: ```python from fastmcp.server import create\_proxy config = { "mcpServers": { "we... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/providers/proxy.mdx | main | model-context-protocol-fastmcp | [
-0.054112955927848816,
0.005624326411634684,
0.07119783014059067,
0.06428927928209305,
-0.059593915939331055,
-0.10118368268013,
-0.038876552134752274,
-0.03093745931982994,
-0.012408632785081863,
-0.005790000315755606,
-0.053013384342193604,
-0.04767690971493721,
0.043536990880966187,
0.0... | -0.035588 |
import { VersionBadge } from '/snippets/version-badge.mdx' Tool transformation lets you modify tool schemas - renaming tools, changing descriptions, adjusting tags, and reshaping argument schemas. FastMCP provides two mechanisms that share the same configuration options but differ in timing. \*\*Deferred transformation... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/transforms/tool-transformation.mdx | main | model-context-protocol-fastmcp | [
-0.1181601732969284,
0.009105765260756016,
-0.021719027310609818,
-0.02416427992284298,
-0.04677557572722435,
-0.01742415502667427,
-0.01719941943883896,
-0.01233314536511898,
-0.020720846951007843,
-0.029802575707435608,
0.060040198266506195,
-0.029814010486006737,
0.06463473290205002,
-0... | -0.008565 |
value. `default\_factory` requires `hide=True`. Visible arguments need static defaults that can be represented in JSON Schema. ## Renaming Arguments Rename arguments to make them more intuitive for LLMs or match your API conventions. ```python from fastmcp.tools import Tool, tool from fastmcp.tools.tool\_transform impo... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/transforms/tool-transformation.mdx | main | model-context-protocol-fastmcp | [
-0.10034281015396118,
0.0673798993229866,
-0.05781935527920723,
0.03668110817670822,
-0.0864100307226181,
0.028705842792987823,
0.004270538687705994,
0.034829746931791306,
0.002843692200258374,
-0.05828800052404404,
0.09519439935684204,
-0.03537788614630699,
0.07595153898000717,
-0.0185821... | 0.040402 |
import { VersionBadge } from '/snippets/version-badge.mdx' Some MCP clients only support tools. They cannot list or read resources directly because they lack resource protocol support. The `ResourcesAsTools` transform bridges this gap by generating tools that provide access to your server's resources. When you add `Res... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/transforms/resources-as-tools.mdx | main | model-context-protocol-fastmcp | [
-0.0818018913269043,
0.03275585174560547,
0.012964433059096336,
-0.013197039254009724,
0.025494052097201347,
-0.041095707565546036,
-0.000669748114887625,
-0.03189481049776077,
-0.010120508261024952,
-0.0461476594209671,
-0.01102045364677906,
0.013909927569329739,
0.0944804698228836,
-0.02... | 0.028361 |
import { VersionBadge } from '/snippets/version-badge.mdx' Transforms modify components as they flow from providers to clients. When a client asks "what tools do you have?", the request passes through each transform in the chain. Each transform can modify the components before passing them along. ## Mental Model Think ... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/transforms/transforms.mdx | main | model-context-protocol-fastmcp | [
-0.11044229567050934,
0.052060820162296295,
0.029852773994207382,
-0.06745344400405884,
-0.013033273629844189,
-0.015388255938887596,
-0.016648633405566216,
-0.04657002538442612,
0.022236036136746407,
-0.04059100151062012,
-0.012035997584462166,
0.011126709170639515,
0.069254070520401,
-0.... | 0.018912 |
implementations that pass through unchanged. Override only the methods relevant to your transform. Each component type has two methods with different patterns: | Method | Pattern | Purpose | |--------|---------|---------| | `list\_tools(tools)` | Pure function | Transform the sequence of tools | | `get\_tool(name, call... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/transforms/transforms.mdx | main | model-context-protocol-fastmcp | [
-0.10098113864660263,
0.01845170557498932,
-0.02730846218764782,
-0.05861138179898262,
0.0034007069189101458,
-0.0010313835227862,
-0.009969912469387054,
0.08304043859243393,
-0.01103750616312027,
0.01775974966585636,
-0.04237722232937813,
-0.05023742839694023,
-0.006114584393799305,
-0.01... | 0.133286 |
import { VersionBadge } from '/snippets/version-badge.mdx' The `Namespace` transform prefixes all component names, preventing conflicts when composing multiple servers. Tools and prompts receive an underscore-separated prefix. Resources and templates receive a path-segment prefix in their URIs. | Component | Original |... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/transforms/namespace.mdx | main | model-context-protocol-fastmcp | [
-0.05298507586121559,
-0.010241173207759857,
0.0193124208599329,
0.0006820772541686893,
0.009875384159386158,
-0.05687331408262253,
-0.03530089929699898,
0.005862033925950527,
0.035793524235486984,
-0.053981490433216095,
0.014550058171153069,
-0.04973848536610603,
0.08047898858785629,
-0.0... | -0.012523 |
import { VersionBadge } from '/snippets/version-badge.mdx' Some MCP clients only support tools. They cannot list or get prompts directly because they lack prompt protocol support. The `PromptsAsTools` transform bridges this gap by generating tools that provide access to your server's prompts. When you add `PromptsAsToo... | https://github.com/jlowin/fastmcp/blob/main//docs/servers/transforms/prompts-as-tools.mdx | main | model-context-protocol-fastmcp | [
-0.028786908835172653,
0.016411345452070236,
0.0344446524977684,
-0.05503755062818527,
0.009524076245725155,
-0.01866726763546467,
0.024543173611164093,
0.0008699704776518047,
-0.015513394959270954,
0.0014189411886036396,
0.006301996298134327,
-0.02400447428226471,
0.10331948101520538,
-0.... | -0.005852 |
# Getting Started with Spacelift Spacelift blends a regular CI's versatility with the methodological rigor of a specialized, security-conscious infrastructure tool. In this guide we will briefly introduce some key concepts that you need to know to work with Spacelift. These concepts will be followed by detailed instruc... | https://github.com/spacelift-io/user-documentation/blob/main//docs/README.md | main | spacelift | [
-0.10471441596746445,
-0.06790459901094437,
0.013355457223951817,
0.004519095178693533,
-0.0680420771241188,
-0.03799492493271828,
0.0016581608215346932,
-0.029712704941630363,
-0.042552102357149124,
0.05607430636882782,
-0.05769145488739014,
-0.09934161603450775,
0.029662471264600754,
-0.... | 0.114363 |
a Spacelift run. This will check the source code and run any commands on it, and you will be taken to the run view. 4. Click \*\*Confirm\*\* to apply your changes. 5. Wait for the run to finish.  Your output will look different based on your code repository and the resources ... | https://github.com/spacelift-io/user-documentation/blob/main//docs/README.md | main | spacelift | [
-0.025730427354574203,
-0.012966597452759743,
0.07631388306617737,
0.016894834116101265,
0.026636764407157898,
-0.10262878984212875,
-0.08124815672636032,
-0.06663491576910019,
-0.0013077547773718834,
0.13137462735176086,
-0.0386190190911293,
-0.02692650817334652,
-0.03522517532110214,
-0.... | -0.038849 |
# Spacelift Self-Hosted Alongside our SaaS product, we also provide a self-hosted version of Spacelift that you can install into your own infrastructure, including AWS, GCP, Azure, and on-premise Kubernetes environments. ## Documentation You can find the documentation for the latest version of self-hosted [here](./self... | https://github.com/spacelift-io/user-documentation/blob/main//docs/self-hosted.md | main | spacelift | [
-0.0324682854115963,
-0.08420491963624954,
0.08664843440055847,
0.02151908539235592,
0.0053179142996668816,
0.012054769322276115,
-0.04367712512612343,
0.007926383055746555,
0.07726507633924484,
0.06877445429563522,
-0.0036817865911871195,
-0.005446175113320351,
-0.015443937852978706,
-0.0... | 0.104434 |
# Resource Sanitization The Terraform state can contain very sensitive data. Sometimes this is unavoidable because of the design of certain Terraform providers or because the definition of what is sensitive isn't always simple and may vary between individuals and organizations. Spacelift provides two different approach... | https://github.com/spacelift-io/user-documentation/blob/main//docs/vendors/terraform/resource-sanitization.md | main | spacelift | [
-0.03410399332642555,
0.054509080946445465,
0.006028010975569487,
0.006934065371751785,
0.0077183847315609455,
-0.01450145710259676,
0.0312536247074604,
-0.02660764940083027,
0.02343948744237423,
0.05184648185968399,
-0.06291501969099045,
-0.05049782618880272,
0.10921059548854828,
0.032818... | 0.051335 |
will be used. ## Smart Sanitization !!! info Due to limitations in the data output by Terraform, Smart Sanitization can only be used on stacks that use Terraform versions 1.0.1 or above. Using an unsupported version will fail. As we rely on the sensitive argument in Terraform to determine which of your values are sensi... | https://github.com/spacelift-io/user-documentation/blob/main//docs/vendors/terraform/resource-sanitization.md | main | spacelift | [
-0.026838019490242004,
0.0473966971039772,
-0.0014895087806507945,
0.024088088423013687,
0.036417532712221146,
-0.044543731957674026,
0.02146974392235279,
-0.07957886904478073,
-0.004338358528912067,
0.02022329345345497,
0.026704272255301476,
-0.06951753795146942,
0.05713938549160957,
0.02... | 0.062382 |
# Cloud Development Kit for Terraform (CDKTF) The [Cloud Development Kit for Terraform (CDKTF)](https://www.terraform.io/cdktf){: rel="nofollow"} generates JSON Terraform configuration from code in C#, Python, TypeScript, Java, or Go. Spacelift fully supports CDKTF. ## Building a custom runner image CDKTF requires pack... | https://github.com/spacelift-io/user-documentation/blob/main//docs/vendors/terraform/cdktf.md | main | spacelift | [
-0.05009646341204643,
0.026096174493432045,
0.016634002327919006,
-0.03085465356707573,
-0.06252839416265488,
-0.014151015318930149,
-0.06540956348180771,
-0.006269256118685007,
-0.020199250429868698,
0.017605315893888474,
-0.046555813401937485,
-0.11449465900659561,
0.01753935031592846,
0... | 0.019749 |
# External state access External state access allows you to read the state of the stack from outside authorized [runs](../../concepts/run/README.md) and [tasks](../../concepts/run/task.md). In particular, this enables sharing the outputs between stacks using the Terraform mechanism of [remote state](https://www.terrafo... | https://github.com/spacelift-io/user-documentation/blob/main//docs/vendors/terraform/external-state-access.md | main | spacelift | [
-0.05652815103530884,
-0.050856951624155045,
-0.03153043985366821,
0.01822526752948761,
-0.013852178119122982,
-0.07501770555973053,
-0.03419721871614456,
-0.03506697341799736,
0.026199527084827423,
0.06745543330907822,
-0.016963506117463112,
0.009592680260539055,
0.027566513046622276,
-0.... | 0.090165 |
# Cost Estimation The [Infracost](https://www.infracost.io/){: rel="nofollow"} integration allows you to run an Infracost breakdown during Spacelift runs, providing feedback on PRs, and allowing you to integrate cost data with [plan policies](../../concepts/policy/terraform-plan-policy.md). This allows you to understan... | https://github.com/spacelift-io/user-documentation/blob/main//docs/vendors/terraform/infracost.md | main | spacelift | [
-0.06740251928567886,
-0.010363326407968998,
0.0034926265943795443,
0.0430867038667202,
0.005698598455637693,
-0.11057930439710617,
-0.03850431740283966,
0.02734331600368023,
0.01266153808683157,
0.08425768464803696,
-0.04276050627231598,
-0.09019121527671814,
0.0388299897313118,
-0.017101... | 0.027974 |
our [resources view](../../concepts/resources/README.md) to allow you to view the cost information for each resource:  | https://github.com/spacelift-io/user-documentation/blob/main//docs/vendors/terraform/infracost.md | main | spacelift | [
-0.017217570915818214,
0.03913765773177147,
-0.11004917323589325,
0.04647156223654747,
0.11764636635780334,
-0.011571202427148819,
0.06735579669475555,
-0.02237691543996334,
0.07925164699554443,
0.016046641394495964,
-0.045669615268707275,
-0.006221033167093992,
0.05144168436527252,
0.0375... | 0.122586 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.