content large_stringlengths 3 20.5k | url large_stringlengths 53 192 ⌀ | branch large_stringclasses 4
values | source large_stringclasses 51
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
import { VersionBadge } from '/snippets/version-badge.mdx' The `fastmcp.Client` class provides a programmatic interface for interacting with any MCP server. It handles protocol details and connection management automatically, letting you focus on the operations you want to perform. The FastMCP Client is designed for de... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/client.mdx | main | model-context-protocol-fastmcp | [
-0.07498263567686081,
-0.006124910898506641,
-0.009951209649443626,
0.0035946958232671022,
-0.04243266209959984,
-0.11479940265417099,
-0.037626851350069046,
-0.0055473786778748035,
-0.04923069104552269,
-0.010250875726342201,
0.02485177293419838,
0.02026325836777687,
0.07468289136886597,
... | 0.112727 |
FastMCP mcp = FastMCP(name="MyServer", instructions="Use the greet tool to say hello!") @mcp.tool def greet(name: str) -> str: """Greet a user by name.""" return f"Hello, {name}!" async with Client(mcp) as client: # Initialization already happened automatically print(f"Server: {client.initialize\_result.serverInfo.name... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/client.mdx | main | model-context-protocol-fastmcp | [
-0.09339859336614609,
0.026995239779353142,
-0.0029440808575600386,
0.05807049572467804,
-0.1031106486916542,
-0.08673299103975296,
0.003854607231914997,
0.0069275470450520515,
-0.01658550091087818,
-0.05573765188455582,
0.0718580111861229,
0.013458199799060822,
0.049120303243398666,
-0.03... | -0.032845 |
import { VersionBadge } from '/snippets/version-badge.mdx' Use this when you need to capture or process log messages sent by the server. MCP servers can emit log messages to clients. The client handles these through a log handler callback. ## Log Handler Provide a `log\_handler` function when creating the client: ```py... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/logging.mdx | main | model-context-protocol-fastmcp | [
-0.021359898149967194,
0.010567832738161087,
0.0635077953338623,
0.014947086572647095,
0.06822344660758972,
-0.046541258692741394,
0.044542886316776276,
-0.019776389002799988,
-0.002237847540527582,
0.007309135515242815,
0.027787795290350914,
-0.03435143455862999,
0.08436666429042816,
-0.0... | 0.001443 |
`fastmcp-remote` is FastMCP's standalone stdio bridge for remote MCP servers. Use it when an MCP host expects to launch a local command, but the server you want to use is hosted over Streamable HTTP or SSE. ```json { "mcpServers": { "linear": { "command": "uvx", "args": ["fastmcp-remote", "https://mcp.linear.app/mcp"] ... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/fastmcp-remote.mdx | main | model-context-protocol-fastmcp | [
-0.0630728006362915,
0.006210925057530403,
0.01666489988565445,
-0.012078161351382732,
-0.046465322375297546,
-0.08334780484437943,
-0.10417873412370682,
0.034165166318416595,
0.0025507293175905943,
0.018719268962740898,
-0.0030041688587516546,
0.0161309652030468,
0.03288296237587929,
-0.0... | 0.031439 |
example-prod ``` If the remote authorization server requires a fixed callback port or hostname, pass them after the URL: ```bash uvx fastmcp-remote https://example.com/mcp 3334 --host 127.0.0.1 ``` ## Options | Option | Description | | ------ | ----------- | | `--transport` | Choose `http` or `sse`. Defaults to `http`.... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/fastmcp-remote.mdx | main | model-context-protocol-fastmcp | [
-0.05787762627005577,
0.06443501263856888,
-0.03953425958752632,
0.0004080907965544611,
-0.005670506507158279,
-0.05821041017770767,
0.014938004314899445,
0.07370748370885849,
-0.002837302628904581,
0.0000946864893194288,
0.010825340636074543,
-0.04717884585261345,
0.10594481229782104,
0.0... | -0.036451 |
import { VersionBadge } from '/snippets/version-badge.mdx' Use this when you need to read data from server-exposed resources like configuration files, generated content, or external data sources. Resources are data sources exposed by MCP servers. They can be static files with fixed content, or dynamic templates that ge... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/resources.mdx | main | model-context-protocol-fastmcp | [
-0.009582867845892906,
0.05433626100420952,
-0.01581498049199581,
0.04099063575267792,
0.060527700930833817,
-0.01595335267484188,
0.013172969222068787,
-0.012930044904351234,
-0.04861827194690704,
-0.028596511110663414,
-0.05108927935361862,
-0.013555388897657394,
0.10165156424045563,
-0.... | 0.021509 |
import { VersionBadge } from "/snippets/version-badge.mdx"; Use this when you need to react to server-side changes like tool list updates or resource modifications. MCP servers can send notifications to inform clients about state changes. The message handler provides a unified way to process these notifications. ## Han... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/notifications.mdx | main | model-context-protocol-fastmcp | [
-0.04836685210466385,
0.024219227954745293,
0.09034544974565506,
0.03781944885849953,
0.07181333005428314,
-0.020839793607592583,
0.06409971415996552,
-0.03376109153032303,
0.01515587791800499,
0.017637822777032852,
-0.017846692353487015,
-0.036800567060709,
0.0783408135175705,
-0.01232552... | 0.033706 |
import { VersionBadge } from "/snippets/version-badge.mdx" Transports handle the underlying connection between your client and MCP servers. While the client can automatically select a transport based on what you pass to it, instantiating transports explicitly gives you full control over configuration. ## STDIO Transpor... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/transports.mdx | main | model-context-protocol-fastmcp | [
0.027441365644335747,
-0.001748938811942935,
0.0258459635078907,
-0.025077758356928825,
-0.010989341884851456,
-0.04926080256700516,
0.004495266359299421,
0.02614564076066017,
-0.022381622344255447,
-0.02459600381553173,
0.008449540473520756,
-0.022172987461090088,
0.07892794162034988,
-0.... | -0.036529 |
testing. ```python from fastmcp import FastMCP, Client import os mcp = FastMCP("TestServer") @mcp.tool def greet(name: str) -> str: prefix = os.environ.get("GREETING\_PREFIX", "Hello") return f"{prefix}, {name}!" client = Client(mcp) async with client: result = await client.call\_tool("greet", {"name": "World"}) ``` Un... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/transports.mdx | main | model-context-protocol-fastmcp | [
-0.052883367985486984,
-0.009365880861878395,
-0.016044558957219124,
0.08848066627979279,
-0.05082312226295471,
-0.1514602154493332,
-0.04527822881937027,
-0.006099612917751074,
0.03941452503204346,
-0.02754245325922966,
0.015887955203652382,
-0.01983497478067875,
0.057069916278123856,
-0.... | -0.000699 |
import { VersionBadge } from "/snippets/version-badge.mdx" OAuth authentication is only relevant for HTTP-based transports and requires user interaction via a web browser. When your FastMCP client needs to access an MCP server protected by OAuth 2.1, and the process requires user interaction (like logging in and granti... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/auth/oauth.mdx | main | model-context-protocol-fastmcp | [
-0.08413687348365784,
0.05423731729388237,
0.009280248545110226,
-0.05188567936420441,
0.007900016382336617,
-0.06551436334848404,
0.002186516532674432,
0.03192633017897606,
-0.007801018189638853,
-0.07271309942007065,
0.016860581934452057,
-0.0002224474010290578,
0.10617899149656296,
-0.0... | -0.055865 |
OAuth server's authorization endpoint. The user logs in and grants (or denies) the requested `scopes`. Upon approval, the OAuth server redirects the user's browser to the local callback server with an `authorization\_code`. The client captures this code and exchanges it with the OAuth server's token endpoint for an `ac... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/auth/oauth.mdx | main | model-context-protocol-fastmcp | [
-0.059658873826265335,
0.018973838537931442,
0.029462212696671486,
0.05258646234869957,
0.05055408179759979,
-0.06471056491136551,
0.0344039686024189,
0.0022357769776135683,
0.07065149396657944,
-0.02695874683558941,
-0.02923157438635826,
0.10026024281978607,
0.04364645108580589,
-0.057862... | 0.089332 |
import { VersionBadge } from "/snippets/version-badge.mdx" Bearer Token authentication is only relevant for HTTP-based transports. You can configure your FastMCP client to use \*\*bearer authentication\*\* by supplying a valid access token. This is most appropriate for service accounts, long-lived API keys, CI/CD, appl... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/auth/bearer.mdx | main | model-context-protocol-fastmcp | [
-0.09900227189064026,
0.0736517384648323,
-0.0030492148362100124,
-0.055633947253227234,
-0.01956663280725479,
-0.03501017764210701,
0.03885091096162796,
0.00004822613118449226,
-0.0037401560693979263,
-0.052669789642095566,
0.03148674964904785,
-0.002241556067019701,
0.1122540831565857,
-... | 0.009034 |
import { VersionBadge } from "/snippets/version-badge.mdx" CIMD authentication is only relevant for HTTP-based transports and requires a server that advertises CIMD support. With standard OAuth, your client registers dynamically with every server it connects to, receiving a fresh `client\_id` each time. This works, but... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/auth/cimd.mdx | main | model-context-protocol-fastmcp | [
-0.14974480867385864,
0.049213506281375885,
-0.02362576685845852,
-0.08278650790452957,
-0.009283972904086113,
-0.07728148251771927,
-0.006611461751163006,
0.025134695693850517,
0.049938932061195374,
-0.028582308441400528,
0.010849783197045326,
-0.027407851070165634,
0.13424761593341827,
-... | 0.002612 |
serve a JSON file over HTTPS. ## Validating Your Document Before deploying, verify your hosted document passes validation: ```bash fastmcp auth cimd validate https://myapp.example.com/oauth/client.json ``` The validator fetches the document and checks that: - The URL is valid (HTTPS, non-root path) - The document is we... | https://github.com/jlowin/fastmcp/blob/main/docs/clients/auth/cimd.mdx | main | model-context-protocol-fastmcp | [
-0.08114099502563477,
0.07677756249904633,
0.002122174948453903,
-0.032006002962589264,
0.0016573629109188914,
-0.11838312447071075,
-0.07430494576692581,
0.04930799826979637,
0.10036099702119827,
-0.022696472704410553,
0.011835793033242226,
-0.025017570704221725,
0.07487800717353821,
-0.0... | 0.023506 |
# `fastmcp.utilities.docstring\_parsing` Extract descriptions from function docstrings. Uses griffelib to parse Google, NumPy, and Sphinx-style docstrings. The interface is intentionally narrow — a single function returning a `ParsedDocstring` — so the implementation can be swapped without touching callers. ## Function... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-docstring_parsing.mdx | main | model-context-protocol-fastmcp | [
-0.09387250244617462,
0.03637629374861717,
0.05624828115105629,
-0.007336394861340523,
-0.04286670312285423,
-0.03723396733403206,
-0.005949389189481735,
0.05370539426803589,
-0.032165948301553726,
-0.0223770122975111,
-0.0004112876486033201,
-0.027278700843453407,
0.04048512130975723,
-0.... | 0.086457 |
# `fastmcp.utilities.cli` ## Functions ### `is\_already\_in\_uv\_subprocess` ```python is\_already\_in\_uv\_subprocess() -> bool ``` Check if we're already running in a FastMCP uv subprocess. ### `load\_and\_merge\_config` ```python load\_and\_merge\_config(server\_spec: str | None, \*\*cli\_overrides) -> tuple[MCPServ... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-cli.mdx | main | model-context-protocol-fastmcp | [
-0.06803622841835022,
-0.028539935126900673,
0.024536967277526855,
0.0021792256738990545,
0.01932196319103241,
-0.12638384103775024,
-0.005167583469301462,
0.009840764105319977,
-0.04784443974494934,
-0.05123427137732506,
0.0627158060669899,
-0.047207243740558624,
0.021617135033011436,
-0.... | -0.007756 |
# `fastmcp.utilities.mcp\_server\_config.v1.mcp\_server\_config` FastMCP Configuration File Support. This module provides support for fastmcp.json configuration files that allow users to specify server settings in a declarative format instead of using command-line arguments. ## Functions ### `generate\_schema` ```pytho... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-mcp_server_config-v1-mcp_server_config.mdx | main | model-context-protocol-fastmcp | [
-0.08444283157587051,
0.016027502715587616,
-0.010083545930683613,
-0.009210331365466118,
0.0016901687486097217,
-0.07875190675258636,
-0.020864784717559814,
-0.013070610351860523,
-0.06713657081127167,
-0.02287982776761055,
0.0911988914012909,
-0.02254747599363327,
0.05185386538505554,
0.... | 0.081605 |
directory - `args`: Server arguments \*\*Returns:\*\* - MCPServerConfig instance #### `find\_config` ```python find\_config(cls, start\_path: Path | None = None) -> Path | None ``` Find a fastmcp.json file in the specified directory. \*\*Args:\*\* - `start\_path`: Directory to look in (defaults to current directory) \*... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-mcp_server_config-v1-mcp_server_config.mdx | main | model-context-protocol-fastmcp | [
-0.12735535204410553,
0.03205762803554535,
-0.03451031073927879,
0.046037543565034866,
0.04045051336288452,
-0.1055464968085289,
-0.01719839498400688,
0.01638331077992916,
-0.012443040497601032,
-0.030648287385702133,
0.11664759367704391,
-0.0069100926630198956,
0.05313483253121376,
0.0080... | -0.009341 |
# `fastmcp.utilities.mcp\_server\_config.v1.sources.base` ## Classes ### `Source` Abstract base class for all source types. \*\*Methods:\*\* #### `prepare` ```python prepare(self) -> None ``` Prepare the source (download, clone, install, etc). For sources that need preparation (e.g., git clone, download), this method p... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-mcp_server_config-v1-sources-base.mdx | main | model-context-protocol-fastmcp | [
-0.0632481575012207,
0.0032075822819024324,
0.02429063245654106,
0.02598317712545395,
0.005922559183090925,
-0.10620962828397751,
-0.012587654404342175,
0.001643235213123262,
-0.07051526755094528,
-0.016731765121221542,
0.07532107084989548,
-0.013731041923165321,
0.06591275334358215,
-0.08... | -0.050109 |
# `fastmcp.experimental.transforms.code\_mode` ## Classes ### `SandboxProvider` Interface for executing LLM-generated Python code in a sandbox. WARNING: The ``code`` parameter passed to ``run`` contains untrusted, LLM-generated Python. Implementations MUST execute it in an isolated sandbox — never with plain ``exec()``... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-experimental-transforms-code_mode.mdx | main | model-context-protocol-fastmcp | [
-0.04424472898244858,
-0.016915179789066315,
-0.04730399325489998,
-0.03390060365200043,
0.00951431691646576,
-0.09483014047145844,
-0.058322273194789886,
0.010847323574125767,
-0.05237424001097679,
-0.031949639320373535,
0.04211856797337532,
-0.05798646807670593,
0.0940110981464386,
-0.03... | -0.017298 |
# `fastmcp.utilities.inspect` Utilities for inspecting FastMCP instances. ## Functions ### `inspect\_fastmcp\_v2` ```python inspect\_fastmcp\_v2(mcp: FastMCP[Any]) -> FastMCPInfo ``` Extract information from a FastMCP v2.x instance. \*\*Args:\*\* - `mcp`: The FastMCP v2.x instance to inspect \*\*Returns:\*\* - FastMCPI... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-inspect.mdx | main | model-context-protocol-fastmcp | [
-0.11086124181747437,
0.02932647243142128,
0.02308170311152935,
0.006565198302268982,
0.06716662645339966,
-0.11246386915445328,
0.01710679940879345,
-0.03698452562093735,
-0.004788902588188648,
-0.09222446382045746,
0.08053518086671829,
-0.025460757315158844,
0.004147636704146862,
-0.0894... | 0.010306 |
# `fastmcp.utilities.mcp\_server\_config.v1.environments.uv` ## Classes ### `UVEnvironment` Configuration for Python environment setup. \*\*Methods:\*\* #### `build\_command` ```python build\_command(self, command: list[str]) -> list[str] ``` Build complete uv run command with environment args and command to execute. \... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-mcp_server_config-v1-environments-uv.mdx | main | model-context-protocol-fastmcp | [
-0.04355213791131973,
0.027011215686798096,
0.014366954565048218,
0.02503821812570095,
-0.033343344926834106,
-0.10095945000648499,
-0.04122499004006386,
0.05055004730820656,
-0.10271011292934418,
-0.0005787825211882591,
0.06393270939588547,
-0.0914398729801178,
0.08805232495069504,
-0.000... | -0.069005 |
# `fastmcp.utilities.lifespan` Lifespan utilities for combining async context manager lifespans. ## Functions ### `combine\_lifespans` ```python combine\_lifespans(\*lifespans: Callable[[AppT], AbstractAsyncContextManager[Mapping[str, Any] | None]]) -> Callable[[AppT], AbstractAsyncContextManager[dict[str, Any]]] ``` C... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-lifespan.mdx | main | model-context-protocol-fastmcp | [
-0.11577016115188599,
-0.009959091432392597,
-0.0020576335955411196,
0.013236211612820625,
-0.009216038510203362,
-0.10383523255586624,
-0.07889635860919952,
0.01871415600180626,
-0.036294497549533844,
-0.04845278337597847,
0.08984483033418655,
-0.07351310551166534,
0.06246989220380783,
-0... | 0.027283 |
# `fastmcp.utilities.tasks` Task configuration primitives for FastMCP components. ## Classes ### `TaskMeta` Metadata for task-augmented execution requests. \*\*Attributes:\*\* - `ttl`: Client-requested TTL in milliseconds. If None, uses server default. - `fn\_key`: Docket routing key. Auto-derived from component name i... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-tasks.mdx | main | model-context-protocol-fastmcp | [
-0.041585542261600494,
0.006708551198244095,
-0.02840377390384674,
0.023383093997836113,
-0.02006065659224987,
-0.09425275772809982,
-0.00675542838871479,
-0.01982658915221691,
-0.0077268690802156925,
0.03225914016366005,
-0.016437411308288574,
-0.03359382972121239,
0.028552955016493797,
-... | 0.04338 |
# `fastmcp.exceptions` Custom exceptions for FastMCP. ## Classes ### `FastMCPDeprecationWarning` Deprecation warning for FastMCP APIs. Subclass of DeprecationWarning so that standard warning filters still apply, but FastMCP can selectively enable its own warnings without affecting other libraries in the process. ### `F... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-exceptions.mdx | main | model-context-protocol-fastmcp | [
-0.05794752389192581,
0.06782331317663193,
0.025841349735856056,
0.012542476877570152,
0.059202175587415695,
-0.04293418675661087,
-0.01154741458594799,
0.029622511938214302,
-0.051110658794641495,
-0.05744296312332153,
0.06057729944586754,
-0.06158437579870224,
0.09131849557161331,
-0.025... | 0.023087 |
# `fastmcp.utilities.components` ## Functions ### `get\_fastmcp\_metadata` ```python get\_fastmcp\_metadata(meta: dict[str, Any] | None) -> FastMCPMeta ``` Extract FastMCP metadata from a component's meta dict. Handles both the current `fastmcp` namespace and the legacy `\_fastmcp` namespace for compatibility with olde... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-components.mdx | main | model-context-protocol-fastmcp | [
-0.06763948500156403,
0.04493188112974167,
-0.02487066574394703,
-0.01735987700521946,
0.01986747793853283,
-0.09005694091320038,
-0.0008837235509417951,
-0.007107629906386137,
-0.02664901874959469,
-0.06020800396800041,
0.05663791671395302,
-0.051590293645858765,
0.04068942368030548,
-0.0... | -0.019618 |
# `fastmcp.utilities.tests` ## Functions ### `temporary\_settings` ```python temporary\_settings(\*\*kwargs: Any) ``` Temporarily override FastMCP setting values. \*\*Args:\*\* - `\*\*kwargs`: The settings to override, including nested settings. ### `run\_server\_in\_process` ```python run\_server\_in\_process(server\_... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-tests.mdx | main | model-context-protocol-fastmcp | [
-0.11694851517677307,
0.015257096849381924,
-0.04794043302536011,
0.02555122599005699,
-0.03712723031640053,
-0.12167680263519287,
-0.003992968704551458,
-0.02235148847103119,
-0.016344433650374413,
-0.02396717481315136,
0.04416826367378235,
-0.04633577913045883,
0.0718911737203598,
-0.063... | 0.015522 |
# `fastmcp.apps.choice` Choice — a Provider that lets the user pick from a set of options. The LLM presents options, the user clicks one, and the selection flows back into the conversation as a message. Requires ``fastmcp[apps]`` (prefab-ui). Usage:: from fastmcp import FastMCP from fastmcp.apps.choice import Choice mc... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-apps-choice.mdx | main | model-context-protocol-fastmcp | [
-0.05301773548126221,
-0.030076980590820312,
0.003614054759964347,
0.03790787607431412,
-0.03071250021457672,
-0.02824573777616024,
0.10864665359258652,
0.04621544107794762,
0.05602316930890083,
-0.017146706581115723,
0.02893996611237526,
-0.043349411338567734,
0.006532955914735794,
-0.011... | 0.098227 |
# `fastmcp.utilities.auth` Authentication utility helpers. ## Functions ### `decode\_jwt\_header` ```python decode\_jwt\_header(token: str) -> dict[str, Any] ``` Decode JWT header without signature verification. Useful for extracting the key ID (kid) for JWKS lookup. \*\*Args:\*\* - `token`: JWT token string (header.pa... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-auth.mdx | main | model-context-protocol-fastmcp | [
-0.14978954195976257,
0.07735957950353622,
0.008097843267023563,
-0.04673541337251663,
0.030295876786112785,
-0.11813928931951523,
0.04787764325737953,
0.013800527900457382,
-0.017913084477186203,
-0.07259993255138397,
0.031314194202423096,
-0.050011154264211655,
0.06909304857254028,
-0.05... | 0.02359 |
# `fastmcp.utilities.json\_schema` ## Functions ### `dereference\_refs` ```python dereference\_refs(schema: dict[str, Any]) -> dict[str, Any] ``` Resolve all $ref references in a JSON schema by inlining definitions. This function resolves $ref references that point to $defs, replacing them with the actual definition co... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-json_schema.mdx | main | model-context-protocol-fastmcp | [
-0.08822180330753326,
0.01689242012798786,
0.05650969222187996,
-0.011900215409696102,
0.0017566841561347246,
-0.06955810636281967,
-0.06379798799753189,
0.020536866039037704,
0.043059274554252625,
0.034828782081604004,
0.056991055607795715,
-0.009368321858346462,
0.03132501617074013,
0.02... | -0.019405 |
# `fastmcp.utilities.timeout` Timeout normalization utilities. ## Functions ### `normalize\_timeout\_to\_timedelta` ```python normalize\_timeout\_to\_timedelta(value: int | float | datetime.timedelta | None) -> datetime.timedelta | None ``` Normalize a timeout value to a timedelta. \*\*Args:\*\* - `value`: Timeout valu... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-timeout.mdx | main | model-context-protocol-fastmcp | [
-0.05400482192635536,
0.09156840294599533,
-0.023061508312821388,
0.02807283028960228,
-0.0614706315100193,
-0.05425122007727623,
-0.05546838790178299,
-0.03149212896823883,
-0.0012659123167395592,
-0.05801877751946449,
0.03995687887072563,
-0.0916878804564476,
-0.01014371495693922,
-0.010... | 0.073314 |
# `fastmcp.apps.form` FormInput — a Provider that collects structured input from the user. Define a Pydantic model for the data you need, and ``FormInput`` generates a form UI. The user fills it out, the submission is validated, and an optional callback processes the result. Requires ``fastmcp[apps]`` (prefab-ui). Usag... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-apps-form.mdx | main | model-context-protocol-fastmcp | [
-0.07887806743383408,
-0.004620532039552927,
-0.023131245747208595,
0.034569114446640015,
-0.07138516753911972,
-0.032487425953149796,
-0.018348533660173416,
0.03965715691447258,
-0.04697956144809723,
-0.014842900447547436,
0.03456553444266319,
-0.06850484013557434,
0.04781869426369667,
-0... | 0.026221 |
# `fastmcp.utilities.version\_check` Version checking utilities for FastMCP. ## Functions ### `get\_latest\_version` ```python get\_latest\_version(include\_prereleases: bool = False) -> str | None ``` Get the latest version of FastMCP from PyPI, using cache when available. \*\*Args:\*\* - `include\_prereleases`: If Tr... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-version_check.mdx | main | model-context-protocol-fastmcp | [
-0.03919108584523201,
0.0228855200111866,
0.04353361949324608,
-0.051805321127176285,
0.06851322948932648,
-0.09108587354421616,
-0.04755362868309021,
-0.040970880538225174,
0.013553785160183907,
-0.07416609674692154,
0.06995847821235657,
-0.0008616698905825615,
-0.029444998130202293,
-0.0... | -0.07331 |
# `fastmcp.utilities.async\_utils` Async utilities for FastMCP. ## Functions ### `is\_coroutine\_function` ```python is\_coroutine\_function(fn: Any) -> bool ``` Check if a callable is a coroutine function, unwrapping functools.partial. ``inspect.iscoroutinefunction`` returns ``False`` for ``functools.partial`` objects... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-async_utils.mdx | main | model-context-protocol-fastmcp | [
-0.09248298406600952,
0.004885094240307808,
-0.03296930342912674,
0.03858490660786629,
0.033105071634054184,
-0.115758016705513,
0.005114730913192034,
-0.05090387165546417,
-0.022736387327313423,
-0.08488652855157852,
0.05890833958983421,
-0.020085126161575317,
-0.0583619549870491,
-0.0312... | 0.036494 |
# `fastmcp.utilities.token\_cache` In-memory cache for token verification results. Provides a generic TTL-based cache for ``AccessToken`` objects, designed to reduce repeated network calls during opaque-token verification. Only \*successful\* verifications should be cached; errors and failures must be retried on every ... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-token_cache.mdx | main | model-context-protocol-fastmcp | [
-0.07909628003835678,
0.031658198684453964,
0.015108995139598846,
0.03635307028889656,
-0.02360427938401699,
-0.1376231163740158,
0.0217546708881855,
0.01477320771664381,
0.037629760801792145,
-0.025427352637052536,
0.00751271890476346,
-0.008341941051185131,
0.010245968587696552,
-0.08262... | 0.062496 |
# `fastmcp.apps.config` MCP Apps support — extension negotiation and typed UI metadata models. Provides constants and Pydantic models for the MCP Apps extension (io.modelcontextprotocol/ui), enabling tools and resources to carry UI metadata for clients that support interactive app rendering. ## Functions ### `app\_conf... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-apps-config.mdx | main | model-context-protocol-fastmcp | [
-0.06191462650895119,
0.029319990426301956,
-0.020781366154551506,
-0.021170834079384804,
0.08307939022779465,
-0.072959303855896,
0.04757886379957199,
0.0607760064303875,
-0.04387282952666283,
0.010640361346304417,
0.038461245596408844,
-0.07611367106437683,
0.05317501351237297,
0.0119274... | 0.123184 |
# `fastmcp.utilities.authorization` Authorization checks for FastMCP components. Auth checks are callables that receive an ``AuthContext`` and return True to allow access or False to deny it. They can also raise ``AuthorizationError`` to deny with a custom message; other exceptions are masked and treated as denial. ## ... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-authorization.mdx | main | model-context-protocol-fastmcp | [
-0.06594330817461014,
0.0895678699016571,
-0.03759663552045822,
-0.001373760518617928,
0.07763729989528656,
-0.1098519116640091,
0.09335043281316757,
-0.03742026165127754,
-0.027796674519777298,
-0.06118647754192352,
0.06692200154066086,
-0.021521249786019325,
0.0745428204536438,
0.0056251... | -0.045531 |
# `fastmcp.apps.generative` GenerativeUI — a Provider that adds LLM-generated UI capabilities. Registers tools and resources from ``prefab\_ui.generative`` so that an LLM can write Prefab Python code, execute it in a sandbox, and render the result as a streaming interactive UI. Requires ``fastmcp[apps]`` (prefab-ui). U... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-apps-generative.mdx | main | model-context-protocol-fastmcp | [
-0.08932533115148544,
-0.054158251732587814,
-0.007483501918613911,
0.04637962579727173,
-0.019484328106045723,
-0.022772669792175293,
-0.05177412927150726,
0.01386108435690403,
-0.0437663234770298,
-0.029714995995163918,
-0.00030815647915005684,
-0.11891902983188629,
0.014377030543982983,
... | 0.044449 |
# `fastmcp.utilities.json\_schema\_type` Convert JSON Schema to Python types with validation. The json\_schema\_to\_type function converts a JSON Schema into a Python type that can be used for validation with Pydantic. It supports: - Basic types (string, number, integer, boolean, null) - Complex types (arrays, objects)... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-json_schema_type.mdx | main | model-context-protocol-fastmcp | [
-0.10939159989356995,
0.041184552013874054,
0.0033976442646235228,
-0.011492116376757622,
0.014396165497601032,
-0.055139679461717606,
-0.04915677756071091,
-0.0003019293653778732,
-0.06590574979782104,
-0.03900863602757454,
0.004629634786397219,
-0.06170402094721794,
0.028388289734721184,
... | 0.048285 |
# `fastmcp.utilities.logging` Logging utilities for FastMCP. ## Functions ### `get\_logger` ```python get\_logger(name: str) -> logging.Logger ``` Get a logger nested under FastMCP namespace. \*\*Args:\*\* - `name`: the name of the logger, which will be prefixed with 'FastMCP.' \*\*Returns:\*\* - a configured logger in... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-logging.mdx | main | model-context-protocol-fastmcp | [
-0.03822345286607742,
0.00011131678184028715,
0.0017188298515975475,
0.02906002849340439,
0.06680643558502197,
-0.11224513500928879,
-0.004403813276439905,
-0.010809161700308323,
-0.00231066532433033,
-0.02028012089431286,
0.05482055991888046,
-0.07061313837766647,
0.05560373142361641,
0.0... | -0.018165 |
# `fastmcp.apps.file\_upload` FileUpload — a Provider that adds drag-and-drop file upload to any server. Lets users upload files directly to the server through an interactive UI, bypassing the LLM context window entirely. The LLM can then read and work with uploaded files through model-visible tools. Requires ``fastmcp... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-apps-file_upload.mdx | main | model-context-protocol-fastmcp | [
-0.05930635333061218,
-0.0388692170381546,
-0.05524297058582306,
0.024690518155694008,
0.03850340098142624,
0.020855190232396126,
-0.053490087389945984,
0.07747478038072586,
0.009281688369810581,
0.036503516137599945,
0.06946706026792526,
0.024777019396424294,
0.08559616655111313,
-0.02211... | 0.020215 |
# `fastmcp.utilities.mcp\_server\_config.v1.environments.base` ## Classes ### `Environment` Base class for environment configuration. \*\*Methods:\*\* #### `build\_command` ```python build\_command(self, command: list[str]) -> list[str] ``` Build the full command with environment setup. \*\*Args:\*\* - `command`: Base ... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-mcp_server_config-v1-environments-base.mdx | main | model-context-protocol-fastmcp | [
-0.03860652819275856,
0.009310826659202576,
0.0007182336412370205,
0.023910926654934883,
0.0038510551676154137,
-0.10034584254026413,
-0.031188709661364555,
0.0355064757168293,
-0.09427882730960846,
-0.0216812901198864,
0.04031745344400406,
-0.07142499089241028,
0.08407995104789734,
-0.024... | -0.04119 |
# `fastmcp.telemetry` OpenTelemetry instrumentation for FastMCP. This module provides native OpenTelemetry integration for FastMCP servers and clients. It uses only the opentelemetry-api package, so telemetry is a no-op unless the user installs an OpenTelemetry SDK and configures exporters. Example usage with SDK: ```p... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-telemetry.mdx | main | model-context-protocol-fastmcp | [
-0.02557585947215557,
0.002626989968121052,
-0.023373616859316826,
-0.01394460629671812,
0.025056321173906326,
-0.13529741764068604,
0.0025615475606173277,
0.05415767803788185,
0.03993663936853409,
0.0037221356760710478,
0.0516904778778553,
-0.05877489969134331,
-0.02524729073047638,
-0.05... | 0.032651 |
# `fastmcp.apps.app` FastMCPApp — a Provider that represents a composable MCP application. FastMCPApp binds entry-point tools (model calls these) together with backend tools (the UI calls these via CallTool). Backend tools are tagged with ``meta["fastmcp"]["app"]`` so they can be found through the provider chain even w... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-apps-app.mdx | main | model-context-protocol-fastmcp | [
-0.136662557721138,
-0.0214195866137743,
-0.02242768369615078,
0.005546248983591795,
0.003698433516547084,
-0.0856267437338829,
0.009892241097986698,
0.03436039015650749,
0.061652690172195435,
-0.03639073297381401,
0.05640742927789688,
-0.055286966264247894,
0.07351115345954895,
-0.0776962... | -0.002008 |
# `fastmcp.utilities.versions` Version comparison utilities for component versioning. This module provides utilities for comparing component versions. Versions are strings that are first attempted to be parsed as PEP 440 versions (using the `packaging` library), falling back to lexicographic string comparison. Examples... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-versions.mdx | main | model-context-protocol-fastmcp | [
-0.0446944497525692,
0.0006480644806288183,
0.029929613694548607,
-0.04000624641776085,
0.03782948851585388,
-0.0656760185956955,
-0.040756795555353165,
0.027601420879364014,
-0.02223910018801689,
-0.061898376792669296,
0.06292807310819626,
0.010180135257542133,
0.006523996591567993,
-0.03... | -0.001666 |
versions >= this value match. - `lt`: If set, only versions < this value match. - `eq`: If set, only this exact version matches (gte/lt ignored). Matching is PEP 440-normalized and `v`-prefix insensitive, so `eq="v1.0"` matches a component versioned `"1.0"`, and `eq="1.0"` matches `"1"` (PEP 440 treats `1` and `1.0` as... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-versions.mdx | main | model-context-protocol-fastmcp | [
-0.049248576164245605,
-0.031115485355257988,
0.04701738804578781,
-0.006797223351895809,
-0.011654669418931007,
-0.021411390975117683,
0.0354735367000103,
-0.005864385049790144,
0.006784230004996061,
-0.06653258204460144,
0.03360572084784508,
-0.003960545640438795,
0.032286014407873154,
-... | 0.022709 |
# `fastmcp.utilities.skills` Client utilities for discovering and downloading skills from MCP servers. ## Functions ### `list\_skills` ```python list\_skills(client: Client) -> list[SkillSummary] ``` List all available skills from an MCP server. Discovers skills by finding resources with URIs matching the `skill://{nam... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-skills.mdx | main | model-context-protocol-fastmcp | [
-0.10191520303487778,
0.03537562116980553,
0.008258508518338203,
0.013650459237396717,
-0.02664896845817566,
-0.062109798192977905,
0.06951575726270676,
-0.044837694615125656,
-0.07018492370843887,
-0.01741797849535942,
0.02945655956864357,
-0.009824072010815144,
0.038668494671583176,
0.00... | 0.023955 |
# `fastmcp.utilities.ui` Shared UI utilities for FastMCP HTML pages. This module provides reusable HTML/CSS components for OAuth callbacks, consent pages, and other user-facing interfaces. ## Functions ### `create\_page` ```python create\_page(content: str, title: str = 'FastMCP', additional\_styles: str = '', csp\_pol... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-ui.mdx | main | model-context-protocol-fastmcp | [
-0.13042323291301727,
0.1204817146062851,
-0.03659101203083992,
0.0473366342484951,
0.019762355834245682,
-0.05951608344912529,
-0.050975993275642395,
-0.032853852957487106,
0.004958247300237417,
-0.06064094603061676,
0.04289492592215538,
0.01160472258925438,
0.11659206449985504,
-0.069796... | -0.015417 |
# `fastmcp.utilities.types` Common types used across FastMCP. ## Functions ### `get\_fn\_name` ```python get\_fn\_name(fn: Callable[..., Any]) -> str ``` ### `get\_cached\_typeadapter` ```python get\_cached\_typeadapter(cls: T) -> TypeAdapter[T] ``` TypeAdapters are heavy objects, and in an application context we'd typ... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-types.mdx | main | model-context-protocol-fastmcp | [
-0.11168792843818665,
-0.013151250779628754,
-0.009502138011157513,
0.020813386887311935,
-0.009288918226957321,
-0.06118001788854599,
0.058547355234622955,
0.0320405513048172,
-0.030529601499438286,
-0.09441494196653366,
-0.007754480931907892,
-0.014752782881259918,
0.007477159146219492,
... | 0.063829 |
# `fastmcp.apps.approval` Approval — a Provider that adds human-in-the-loop approval to any server. The LLM presents a summary of what it's about to do, and the user approves or rejects via buttons. The result is sent back into the conversation as a message, prompting the LLM's next turn. Requires ``fastmcp[apps]`` (pr... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-apps-approval.mdx | main | model-context-protocol-fastmcp | [
-0.08504576236009598,
0.006046643014997244,
0.050607506185770035,
0.00504468847066164,
0.057377252727746964,
-0.09797611832618713,
0.05788528919219971,
0.003521176055073738,
0.06633210927248001,
0.005049021448940039,
0.068276546895504,
-0.03335343673825264,
0.015396703965961933,
-0.0550686... | 0.083945 |
# `fastmcp.utilities.pagination` Pagination utilities for MCP list operations. ## Functions ### `paginate\_sequence` ```python paginate\_sequence(items: Sequence[T], cursor: str | None, page\_size: int) -> tuple[list[T], str | None] ``` Paginate a sequence of items. \*\*Args:\*\* - `items`: The full sequence to paginat... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-pagination.mdx | main | model-context-protocol-fastmcp | [
-0.14891210198402405,
-0.015880949795246124,
0.056257762014865875,
-0.03240933269262314,
-0.03245760127902031,
-0.029470710083842278,
-0.006861815229058266,
-0.08078087121248245,
-0.042955465614795685,
0.009542643092572689,
0.06056299805641174,
0.03157227486371994,
0.07315359264612198,
-0.... | 0.063654 |
# `fastmcp.mcp\_config` Canonical MCP Configuration Format. This module defines the standard configuration format for Model Context Protocol (MCP) servers. It provides a client-agnostic, extensible format that can be used across all MCP implementations. The configuration format supports both stdio and remote (HTTP/SSE)... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-mcp_config.mdx | main | model-context-protocol-fastmcp | [
-0.04421393945813179,
-0.0263544749468565,
-0.004535968415439129,
0.0031242661643773317,
-0.009016330353915691,
-0.0689307451248169,
-0.024662423878908157,
0.038585029542446136,
-0.019906580448150635,
-0.02090677060186863,
0.024202721193432808,
-0.0035628180485218763,
0.05164121836423874,
... | 0.085065 |
# `fastmcp.utilities.mime` MIME type constants and helpers for MCP Apps UI resources. This module has no dependencies on the server or resource packages, so it can be safely imported from anywhere. ## Functions ### `resolve\_ui\_mime\_type` ```python resolve\_ui\_mime\_type(uri: str, explicit\_mime\_type: str | None) -... | https://github.com/jlowin/fastmcp/blob/main/docs/python-sdk/fastmcp-utilities-mime.mdx | main | model-context-protocol-fastmcp | [
-0.10559549182653427,
-0.005355144385248423,
0.05889721214771271,
0.042711518704891205,
0.04192918539047241,
-0.0897839292883873,
0.034076955169439316,
0.06359551101922989,
-0.016378190368413925,
-0.07539483904838562,
0.05288948863744736,
-0.0029661504086107016,
0.05282532423734665,
0.0588... | 0.071837 |
import { VersionBadge } from "/snippets/version-badge.mdx" FastMCP provides a command-line interface (CLI) that makes it easy to run, develop, and install your MCP servers. The CLI is automatically installed when you install FastMCP. ```bash fastmcp --help ``` ## Commands Overview | Command | Purpose | Dependency Manag... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.057269129902124405,
-0.03385637700557709,
0.041877489537000656,
-0.06089083477854729,
0.04859178140759468,
-0.023083647713065147,
-0.031156964600086212,
-0.005984670482575893,
-0.05446551367640495,
0.013715695589780807,
0.06743600964546204,
-0.03053947165608406,
0.017604384571313858,
-0... | 0.058656 |
1. \*\*URLs\*\* — `http://` or `https://` endpoints. Uses Streamable HTTP by default; pass `--transport sse` for SSE servers. 2. \*\*Python files\*\* — `.py` files are run via `fastmcp run` automatically. 3. \*\*MCPConfig JSON\*\* — `.json` files with an `mcpServers` key are treated as multi-server configs. 4. \*\*Stdi... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.052973996847867966,
-0.03925085440278053,
-0.033888936042785645,
0.0032869616989046335,
-0.01826128177344799,
-0.055435143411159515,
-0.06457892060279846,
0.05719297006726265,
-0.011165439151227474,
0.002521736780181527,
0.024403490126132965,
-0.019652538001537323,
0.04319065436720848,
... | 0.068069 |
`uv run` subprocess instead. ### Options | Option | Flag | Description | | ------ | ---- | ----------- | | Transport | `--transport`, `-t` | Transport protocol to use (`stdio`, `http`, or `sse`) | | Host | `--host` | Host to bind to when using http transport (default: 127.0.0.1) | | Port | `--port`, `-p` | Port to bind... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.027097607031464577,
-0.009588933549821377,
-0.06698764860630035,
-0.004063658881932497,
-0.04920896142721176,
-0.07748450338840485,
-0.0416213758289814,
0.09567879140377045,
-0.05188611149787903,
0.013029079884290695,
-0.016027091071009636,
-0.05193138122558594,
0.023170344531536102,
0.... | 0.012711 |
hello() -> str: return "Hello from custom server!" ``` You can run it with: ```bash fastmcp run server.py:my\_server ``` #### Factory Function Since `fastmcp run` ignores the `if \_\_name\_\_ == "\_\_main\_\_"` block, you can use a factory function to run setup code before your server starts. Factory functions are call... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.0959702581167221,
-0.05270743370056152,
-0.05938565358519554,
0.009494989179074764,
-0.06414522975683212,
-0.05184087157249451,
-0.051949769258499146,
0.004724784754216671,
-0.07433489710092545,
-0.05676078423857689,
0.10628735274076462,
0.006300112698227167,
0.04983343556523323,
-0.080... | 0.000114 |
inspector` command is a shortcut for testing a server over STDIO only. When the Inspector launches, you may need to: 1. Select "STDIO" from the transport dropdown 2. Connect manually This command does not support HTTP testing. To test a server over Streamable HTTP or SSE: 1. Start your server manually with the appropri... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.03092776983976364,
0.009285863488912582,
-0.038356389850378036,
0.019034259021282196,
-0.01559120137244463,
-0.08900091052055359,
-0.11053355038166046,
0.009742464870214462,
-0.0321279913187027,
0.00869038887321949,
0.022874867543578148,
-0.036163125187158585,
-0.003273581387475133,
-0.... | -0.037356 |
shell command to run a server over stdio transport ```bash fastmcp install claude-code server.py fastmcp install claude-desktop server.py fastmcp install cursor server.py fastmcp install gemini-cli server.py fastmcp install goose server.py fastmcp install mcp-json server.py fastmcp install stdio server.py ``` Note that... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.05242202430963516,
-0.018865905702114105,
-0.03020850010216236,
-0.0873929113149643,
-0.03052639029920101,
-0.04650918021798134,
-0.043019849807024,
0.0489596463739872,
-0.047500550746917725,
-0.020662767812609673,
0.05865093320608139,
-0.04518716037273407,
0.010831596329808235,
0.01368... | -0.075704 |
name and dependencies fastmcp install claude-desktop server.py:my\_server --server-name "My Analysis Server" --with pandas # Install in Claude Code with environment variables fastmcp install claude-code server.py --env API\_KEY=secret --env DEBUG=true # Install in Cursor with environment variables fastmcp install curso... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.10178623348474503,
-0.0429188534617424,
-0.02565614879131317,
-0.04878390580415726,
-0.010338782332837582,
-0.08302325010299683,
-0.050948385149240494,
0.0019437539158388972,
-0.06113763526082039,
-0.001347124925814569,
0.09279437363147736,
-0.03278946131467819,
-0.00548721244558692,
-0... | -0.099689 |
| Option | Flag | Description | | ------ | ---- | ----------- | | Format | `--format`, `-f` | Output format: `fastmcp` (FastMCP-specific) or `mcp` (MCP protocol). Required when using `-o` | | Output File | `--output`, `-o` | Save JSON report to file instead of stdout. Requires `--format` | ### Output Formats #### FastM... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.034123148769140244,
0.046587612479925156,
-0.04892046004533768,
0.013455132953822613,
0.058101192116737366,
-0.0021006292663514614,
-0.06256287544965744,
0.019928032532334328,
-0.02986975386738777,
-0.02954435721039772,
0.08215916156768799,
-0.040280044078826904,
0.0016520516946911812,
... | 0.047782 |
is useful when you want to separate environment setup from server execution, such as in deployment scenarios where dependencies are installed once and the server is run multiple times. ## `fastmcp auth` Authentication-related utilities and configuration commands. ### `fastmcp auth cimd create` Generate a CIMD (Client I... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/cli.mdx | main | model-context-protocol-fastmcp | [
-0.06449372321367264,
0.047205131500959396,
-0.020841607823967934,
-0.06766568124294281,
-0.021385708823800087,
-0.0876975953578949,
-0.03664730489253998,
0.04926266521215439,
0.039761919528245926,
-0.005056032445281744,
0.044513262808322906,
-0.06222210079431534,
0.07940156757831573,
-0.0... | -0.015879 |
The best way to ensure a reliable and maintainable FastMCP Server is to test it! The FastMCP Client combined with Pytest provides a simple and powerful way to test your FastMCP servers. ## Prerequisites Testing FastMCP servers requires `pytest-asyncio` to handle async test functions and fixtures. Install it as a develo... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/testing.mdx | main | model-context-protocol-fastmcp | [
-0.06036306917667389,
0.002273860154673457,
0.022936100140213966,
0.06392118334770203,
-0.028451908379793167,
-0.10525081306695938,
-0.08066757023334503,
0.0013872297713533044,
-0.034630004316568375,
-0.060996443033218384,
0.03288336098194122,
-0.017358725890517235,
0.021417435258626938,
0... | -0.058017 |
import { VersionBadge } from "/snippets/version-badge.mdx" FastMCP includes a `contrib` package that holds community-contributed modules. These modules extend FastMCP's functionality but aren't officially maintained by the core team. Contrib modules provide additional features, integrations, or patterns that complement... | https://github.com/jlowin/fastmcp/blob/main/docs/patterns/contrib.mdx | main | model-context-protocol-fastmcp | [
-0.09353691339492798,
-0.025817589834332466,
0.00981759000569582,
-0.02603747323155403,
0.06956575065851212,
-0.027691662311553955,
-0.014376899227499962,
-0.015706866979599,
-0.06601950526237488,
-0.1009146124124527,
0.08301759511232376,
-0.024965286254882812,
0.052337635308504105,
-0.024... | 0.036594 |
import { VersionBadge } from "/snippets/version-badge.mdx" Good tests are the foundation of reliable software. In FastMCP, we treat tests as first-class documentation that demonstrates how features work while protecting against regressions. Every new capability needs comprehensive tests that demonstrate correctness. ##... | https://github.com/jlowin/fastmcp/blob/main/docs/development/tests.mdx | main | model-context-protocol-fastmcp | [
-0.036509692668914795,
0.02599659562110901,
0.04486207664012909,
-0.015731796622276306,
0.05515924096107483,
-0.0882062166929245,
-0.020785227417945862,
0.019889365881681442,
-0.04870092496275902,
-0.013418378308415413,
0.06332764029502869,
0.026183949783444405,
0.05332035943865776,
0.0299... | -0.021088 |
test\_setup\_server(): """Setup for other tests.""" global test\_server test\_server = FastMCP("shared-server") def test\_server\_works(): """Test server functionality.""" # Depends on test\_setup\_server running first assert test\_server is not None ``` #### Clear Intent Test names and assertions should make the verif... | https://github.com/jlowin/fastmcp/blob/main/docs/development/tests.mdx | main | model-context-protocol-fastmcp | [
-0.1015302985906601,
-0.01914246752858162,
-0.03718133643269539,
0.06126740947365761,
-0.026265908032655716,
-0.06278336048126221,
0.007621889468282461,
-0.06545277684926987,
-0.029286867007613182,
-0.02814970351755619,
0.09003610908985138,
-0.04414059594273567,
0.09596667438745499,
0.0227... | -0.014541 |
test\_weather\_operations(): # Pass server directly - no deployment needed async with Client(server) as client: result = await client.call\_tool("get\_temperature", {"city": "NYC"}) assert result.data == {"city": "NYC", "temp": 72} ``` This pattern makes tests deterministic and fast - typically completing in millisecon... | https://github.com/jlowin/fastmcp/blob/main/docs/development/tests.mdx | main | model-context-protocol-fastmcp | [
-0.0482586994767189,
-0.0052968282252550125,
0.02507450245320797,
0.13305532932281494,
-0.08448008447885513,
-0.1360350102186203,
0.0030875219963490963,
-0.0707809329032898,
-0.05400586500763893,
0.001970705110579729,
0.040973685681819916,
-0.07984257489442825,
0.049956172704696655,
-0.028... | -0.039924 |
Contributing to FastMCP means joining a community that values clean, maintainable code and thoughtful API design. All contributions are valued - from fixing typos in documentation to implementing major features. ## Design Principles Every contribution should advance these principles: - 🚀 \*\*Fast\*\* — High-level inte... | https://github.com/jlowin/fastmcp/blob/main/docs/development/contributing.mdx | main | model-context-protocol-fastmcp | [
-0.1190856322646141,
0.03968435153365135,
0.030032556504011154,
0.004871726967394352,
0.01589474454522133,
-0.027573004364967346,
-0.046516839414834976,
0.00139286566991359,
-0.06010732799768448,
-0.01446058601140976,
0.05468204990029335,
-0.037123631685972214,
0.05158219113945961,
-0.0196... | 0.094874 |
that changes 50 lines across 3 files can be thoroughly reviewed in minutes. A PR that changes 500 lines across 20 files requires hours of careful analysis and often hides subtle issues. Breaking large features into smaller PRs: - Creates better review experiences - Makes git history clear - Simplifies debugging with bi... | https://github.com/jlowin/fastmcp/blob/main/docs/development/contributing.mdx | main | model-context-protocol-fastmcp | [
-0.13932546973228455,
0.054103683680295944,
-0.006729314103722572,
0.003690891433507204,
0.035001277923583984,
-0.08400635421276093,
0.003241469617933035,
0.049557775259017944,
0.052338745445013046,
0.06235266849398613,
0.07369917631149292,
0.03549724072217941,
0.04259723052382469,
-0.0810... | 0.036132 |
``` ### Submitting Your PR #### Before Submitting 1. \*\*Run all checks\*\*: `uv run prek run --all-files && uv run pytest` 2. \*\*Keep scope small\*\*: One feature or fix per PR 3. \*\*Write clear description\*\*: Your PR description becomes permanent documentation 4. \*\*Update docs\*\*: Include documentation for API... | https://github.com/jlowin/fastmcp/blob/main/docs/development/contributing.mdx | main | model-context-protocol-fastmcp | [
-0.09490016102790833,
0.06082504242658615,
0.016180317848920822,
-0.04202813655138016,
0.08846713602542877,
-0.014120224863290787,
0.020793462172150612,
0.08049025386571884,
-0.05893637239933014,
0.06267857551574707,
0.07932308316230774,
-0.05062129348516464,
0.028636159375309944,
0.009618... | 0.006808 |
FastMCP releases frequently to deliver features quickly in the rapidly evolving MCP ecosystem. We use semantic versioning pragmatically - the Model Context Protocol is young, patterns are still emerging, and waiting for perfect stability would mean missing opportunities to empower developers with better tools. ## Versi... | https://github.com/jlowin/fastmcp/blob/main/docs/development/releases.mdx | main | model-context-protocol-fastmcp | [
-0.04021451622247696,
0.04065835475921631,
0.11236821115016937,
-0.038588155061006546,
0.12127432227134705,
-0.03917226940393448,
-0.10266092419624329,
-0.06161292642354965,
-0.04866621643304825,
-0.0011659970041364431,
0.04268447682261467,
-0.029230307787656784,
-0.03737775981426239,
-0.0... | 0.041447 |
fixes This approach means you get improvements as soon as they're ready rather than waiting for arbitrary release dates. | https://github.com/jlowin/fastmcp/blob/main/docs/development/releases.mdx | main | model-context-protocol-fastmcp | [
-0.02922416292130947,
-0.015252199023962021,
0.11128921061754227,
-0.01964293234050274,
0.04883607104420662,
-0.012222988530993462,
-0.11393625289201736,
-0.0347290001809597,
-0.034256577491760254,
0.04475676268339157,
0.06258974969387054,
0.09474637359380722,
-0.08527372032403946,
0.00489... | 0.011417 |
This document tracks major features in FastMCP v3.0 for release notes preparation. ## 3.0.0rc1 ### SamplingTool Conversion Helpers Server tools (FunctionTool and TransformedTool) can now be passed directly to sampling methods via `SamplingTool.from\_callable\_tool()` ([#3062](https://github.com/PrefectHQ/fastmcp/pull/3... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.12627853453159332,
-0.0248640738427639,
-0.011354641057550907,
0.007141181733459234,
-0.00047686509788036346,
-0.09251151233911514,
-0.0002963323495350778,
-0.010445503517985344,
-0.0050271120853722095,
-0.04296557232737541,
0.02485046163201332,
-0.05013584718108177,
0.016218043863773346,... | 0.015565 |
Checks Auth check functions can now be `async`, enabling authorization decisions that depend on asynchronous operations like reading server state via `Context.get\_state` or calling external services ([#3150](https://github.com/PrefectHQ/fastmcp/issues/3150)). Sync and async checks can be freely mixed. Previously, pass... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.10517708212137222,
-0.00327053340151906,
-0.041669681668281555,
0.0367327556014061,
0.03225821629166603,
-0.01612064614892006,
0.033014290034770966,
-0.06724630296230316,
0.0027994252741336823,
0.01553000696003437,
0.0835358053445816,
-0.024773262441158295,
0.020241515710949898,
-0.0091... | 0.067177 |
`fastmcp list` and `fastmcp call`. ```bash # See all configured servers fastmcp discover # Use a server by name fastmcp list weather fastmcp call weather get\_forecast city=London # Target a specific source with source:name fastmcp list claude-code:my-server fastmcp call cursor:weather get\_forecast city=London # Filte... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.10394813865423203,
-0.0007187338778749108,
0.0319984070956707,
0.010167901404201984,
0.08130748569965363,
-0.07982812076807022,
0.062356580048799515,
-0.01316775567829609,
-0.021159028634428978,
-0.0346977598965168,
-0.006430827546864748,
0.00019318847625982016,
-0.01283750869333744,
-0... | 0.030347 |
generate-cli` connects to any MCP server, reads its tool schemas, and writes a standalone Python CLI script where every tool becomes a typed subcommand with flags, help text, and tab completion ([#3065](https://github.com/PrefectHQ/fastmcp/pull/3065)). The insight is that MCP tool schemas already contain everything a C... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.08755078911781311,
0.021672377362847328,
-0.031465888023376465,
-0.007877909578382969,
-0.03926294296979904,
-0.08145155757665634,
-0.027115147560834885,
0.009187835268676281,
-0.03979002311825752,
-0.06973282992839813,
0.006709383800625801,
-0.11876425892114639,
0.09560567140579224,
0.... | -0.008311 |
\*\*Breaking change from beta 2:\*\* The `ui=` parameter on `@mcp.tool()` and `@mcp.resource()` has been renamed to `app=`, and the `ToolUI`/`ResourceUI` classes have been consolidated into a single `AppConfig` class. This follows the established `task=True`/`TaskConfig` pattern. The wire format (`meta["ui"]`, `\_meta.... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.12768688797950745,
-0.011760844849050045,
0.020867368206381798,
0.05047821253538132,
0.004411873873323202,
-0.05976086109876633,
0.04798157140612602,
-0.00442618690431118,
-0.04210203140974045,
-0.03138142451643944,
0.047990232706069946,
-0.056927550584077835,
0.02744687721133232,
0.014... | 0.064658 |
\*\*Lifecycle management\*\*: `async def lifespan()` for setup/teardown - \*\*Visibility control\*\*: `enable()` / `disable()` with name, version, tags, components, and allowlist mode - \*\*Transform stacking\*\*: `provider.add\_transform(Namespace(...))`, `provider.add\_transform(ToolTransform(...))` ### LocalProvider... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.13845175504684448,
0.007232364732772112,
0.008665823377668858,
0.05489726737141609,
-0.018801426514983177,
-0.07934269309043884,
-0.033005908131599426,
-0.007588406093418598,
-0.04357878863811493,
-0.03259922191500664,
0.09154017269611359,
0.005668411497026682,
0.0427665114402771,
-0.00... | 0.01275 |
"value"} mcp.add\_transform(ResourcesAsTools(mcp)) # Now has list\_resources and read\_resource tools ``` The `list\_resources` tool returns JSON with resource metadata. The `read\_resource` tool accepts a URI and returns the resource content, preserving both text and binary data through base64 encoding. \*\*PromptsAsT... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.01905614510178566,
0.06421583145856857,
-0.06398726254701614,
0.020195072516798973,
-0.024059126153588295,
-0.052682727575302124,
0.04466397315263748,
0.022639069706201553,
-0.0023176062386482954,
-0.010931984521448612,
0.004576663952320814,
-0.07018064707517624,
0.0662151500582695,
-0.... | 0.029337 |
individually mcp.disable(tags={"premium"}) ``` Session visibility methods: - `await ctx.enable\_components(...)`: Enable components for this session - `await ctx.disable\_components(...)`: Disable components for this session - `await ctx.reset\_visibility()`: Clear session rules, return to global defaults Session rules... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.054187651723623276,
0.013077234849333763,
0.05254615843296051,
0.049219761043787,
0.04345732182264328,
-0.010622062720358372,
0.022345324978232384,
-0.04698103666305542,
-0.03251637518405914,
0.00083587144035846,
0.02968066930770874,
0.02246466465294361,
0.014787082560360432,
-0.0266964... | 0.01037 |
MCP ContentBlocks (text, images, etc.) - `structured\_content`: Dict matching tool's output schema - `meta`: Runtime metadata passed to MCP as `\_meta` #### ResourceResult `ResourceResult` (`fastmcp\_slim/fastmcp/resources/resource.py:117`) provides structured resource responses: ```python from fastmcp.resources import... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.027943205088377,
0.03915126621723175,
0.017464516684412956,
0.03283333405852318,
0.035944048315286636,
-0.044451117515563965,
0.03503793105483055,
0.04420541971921921,
-0.019192643463611603,
-0.027801768854260445,
0.04716042801737785,
-0.07722857594490051,
0.07984716445207596,
0.0238517... | 0.034611 |
a server instance and decorating functions with `@server.tool`, you use standalone decorators in separate files and let the provider discover them. \*\*The problem it solves\*\*: Traditional servers require coordination between files—either tool files import the server (creating coupling) or the server imports all tool... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.13586732745170593,
0.04051069915294647,
0.029885241761803627,
0.022952932864427567,
-0.034549787640571594,
-0.096279077231884,
0.009416557848453522,
-0.026353375986218452,
0.020027056336402893,
0.007127551827579737,
0.06466980278491974,
-0.004903283901512623,
0.04612300917506218,
-0.010... | -0.00916 |
```python async with Client(server) as client: result = await client.list\_tools\_mcp() while result.nextCursor: result = await client.list\_tools\_mcp(cursor=result.nextCursor) ``` Documentation: [Pagination](/servers/pagination) --- ### Composable Lifespans Lifespans can be combined with the `|` operator for modular ... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.13187430799007416,
0.019616328179836273,
0.010963131673634052,
0.048742588609457016,
-0.06963030993938446,
-0.07637574523687363,
-0.04746443033218384,
-0.027683362364768982,
-0.01848776265978813,
-0.0006916052661836147,
0.044590745121240616,
0.06146741658449173,
0.07055669277906418,
-0.... | -0.010802 |
isinstance(greet, FunctionTool) # True # v3.0 @mcp.tool def greet(name: str) -> str: return f"Hello, {name}!" isinstance(greet, FunctionTool) # False callable(greet) # True - it's still your function greet("World") # "Hello, World!" ``` Set `FASTMCP\_DECORATOR\_MODE=object` or `fastmcp.settings.decorator\_mode = "objec... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/v3-features.mdx | main | model-context-protocol-fastmcp | [
-0.06616424769163132,
0.05032572150230408,
0.050394292920827866,
0.07831300050020218,
-0.011777479201555252,
-0.05433027818799019,
-0.015163430012762547,
-0.029609084129333496,
-0.053022973239421844,
-0.046590354293584824,
0.06779075413942337,
0.02768128365278244,
-0.04206819087266922,
-0.... | 0.017449 |
## Decision: Remove automatic environment variable loading from auth providers You can still use environment variables for configuration - you just read them yourself with `os.environ` instead of relying on FastMCP's automatic loading. \*\*Status:\*\* Implemented in v3.0.0 ### Background Auth providers in v2.x used `py... | https://github.com/jlowin/fastmcp/blob/main/docs/development/v3-notes/auth-provider-env-vars.mdx | main | model-context-protocol-fastmcp | [
-0.02417360059916973,
0.008111607283353806,
-0.04044982045888901,
-0.016030464321374893,
0.022069396451115608,
-0.0365561842918396,
-0.0028931647539138794,
-0.018306346610188484,
-0.028052369132637978,
-0.030537201091647148,
0.07773210853338242,
-0.018676085397601128,
0.08223579078912735,
... | -0.032763 |
import { VersionBadge } from '/snippets/version-badge.mdx' `fastmcp list` and `fastmcp call` are general-purpose — you always specify the server, the tool name, and the arguments from scratch. `fastmcp generate-cli` goes further: it connects to a server, reads its tool schemas, and writes a standalone Python script whe... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/generate-cli.mdx | main | model-context-protocol-fastmcp | [
-0.08039005845785141,
0.008526052348315716,
-0.01191256195306778,
-0.04186626151204109,
0.005602885037660599,
-0.0523451566696167,
-0.001707680756226182,
0.006983163766562939,
-0.051271308213472366,
-0.061017077416181564,
0.033618196845054626,
-0.0718487948179245,
0.09842822700738907,
0.00... | 0.062376 |
python cli.py call-tool get\_forecast --city London ``` | https://github.com/jlowin/fastmcp/blob/main/docs/cli/generate-cli.mdx | main | model-context-protocol-fastmcp | [
-0.027373693883419037,
0.00979643315076828,
-0.009660026989877224,
0.03591004014015198,
-0.07637329399585724,
-0.09623870998620987,
0.009509924799203873,
0.013651032000780106,
-0.0224023275077343,
-0.06340229511260986,
-0.05907587334513664,
-0.06181413680315018,
-0.07310311496257782,
0.008... | -0.048303 |
import { VersionBadge } from '/snippets/version-badge.mdx' The `fastmcp` CLI is installed automatically with FastMCP. It's the primary way to run, test, install, and interact with MCP servers from your terminal. ```bash fastmcp --help ``` ## Commands at a Glance | Command | What it does | | ------- | ------------ | | [... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/overview.mdx | main | model-context-protocol-fastmcp | [
-0.04790613800287247,
-0.05356402322649956,
0.0077921925112605095,
-0.06464260071516037,
0.05129449814558029,
-0.026932088658213615,
-0.05892637372016907,
0.006318595726042986,
-0.046338729560375214,
-0.016892334446310997,
0.044756803661584854,
-0.03119494952261448,
0.02637500874698162,
-0... | 0.016582 |
import { VersionBadge } from '/snippets/version-badge.mdx' The `fastmcp auth` commands help with CIMD (Client ID Metadata Document) management — part of MCP's OAuth authentication flow. A CIMD is a JSON document you host at an HTTPS URL to identify your client application to MCP servers. ## Creating a CIMD `fastmcp aut... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/auth.mdx | main | model-context-protocol-fastmcp | [
-0.08673505485057831,
0.07720054686069489,
-0.006234673783183098,
-0.054852165281772614,
0.027463149279356003,
-0.039001137018203735,
-0.0369744710624218,
0.04466565325856209,
0.026509054005146027,
-0.016124989837408066,
0.03978398069739342,
-0.04585636779665947,
0.0816134586930275,
-0.046... | 0.007114 |
import { VersionBadge } from '/snippets/version-badge.mdx' The CLI can act as an MCP client — connecting to any server (local or remote) to list what it exposes and call its tools directly. This is useful for development, debugging, scripting, and giving shell-capable LLM agents access to MCP servers. ## Listing Tools ... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/client.mdx | main | model-context-protocol-fastmcp | [
-0.03992827236652374,
0.019770922139286995,
0.01978174038231373,
-0.05570719763636589,
0.03669242933392525,
-0.037860359996557236,
-0.009537376463413239,
0.004106772132217884,
-0.043241266161203384,
-0.04697323590517044,
0.015460156835615635,
-0.018800964578986168,
0.07849591225385666,
-0.... | 0.046669 |
question or `cancel` to abort the call entirely. ### Options | Option | Flag | Description | | ------ | ---- | ----------- | | Command | `--command` | Connect via stdio | | Transport | `--transport`, `-t` | Force `http` or `sse` | | Input JSON | `--input-json` | Base arguments as JSON (merged with `key=value`) | | JSON... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/client.mdx | main | model-context-protocol-fastmcp | [
-0.06917482614517212,
0.06369765102863312,
-0.046398602426052094,
0.004928785841912031,
-0.00021173169079702348,
-0.1102057620882988,
0.03211414813995361,
-0.01970501057803631,
-0.0027714846655726433,
0.0037493675481528044,
0.07659276574850082,
-0.0281215813010931,
0.027652814984321594,
-0... | 0.062375 |
import { VersionBadge } from '/snippets/version-badge.mdx' `fastmcp inspect` loads a server and reports what it contains — its tools, resources, prompts, version, and metadata. The default output is a human-readable summary: ```bash fastmcp inspect server.py ``` ``` Server: MyServer Instructions: A helpful MCP server V... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/inspecting.mdx | main | model-context-protocol-fastmcp | [
-0.06065540760755539,
0.049338292330503464,
0.007382447365671396,
-0.02945360541343689,
0.06757673621177673,
-0.04918603226542473,
-0.027419906109571457,
0.008939217776060104,
-0.022305747494101524,
-0.04709881916642189,
0.05631469562649727,
-0.008006694726645947,
0.028224390000104904,
-0.... | 0.060444 |
import { VersionBadge } from '/snippets/version-badge.mdx' `fastmcp install` registers a server with an MCP client application so the client can launch it automatically. Each MCP client runs servers in its own isolated environment, which means dependencies need to be explicitly declared — you can't rely on whatever hap... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/install-mcp.mdx | main | model-context-protocol-fastmcp | [
-0.018537048250436783,
-0.02830212004482746,
-0.009164507500827312,
-0.11896839737892151,
0.013077653013169765,
-0.032891687005758286,
-0.0786522924900055,
0.024929599836468697,
-0.05431969836354256,
-0.001598311006091535,
0.046741191297769547,
-0.022757692262530327,
0.0456327460706234,
-0... | -0.095132 |
fastmcp install mcp-json server.py ``` The output follows the standard format used by Claude Desktop, Cursor, and other MCP clients: ```json { "server-name": { "command": "uv", "args": ["run", "--with", "fastmcp", "fastmcp", "run", "/path/to/server.py"], "env": { "API\_KEY": "value" } } } ``` Use `--copy` to send it to... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/install-mcp.mdx | main | model-context-protocol-fastmcp | [
-0.03229624032974243,
-0.011761190369725227,
-0.020913323387503624,
-0.051709745079278946,
-0.04088063910603523,
-0.06661077588796616,
-0.04153341054916382,
0.059087082743644714,
-0.010638786479830742,
-0.054897043853998184,
0.09138664603233337,
-0.04841027781367302,
0.029974663630127907,
... | -0.026691 |
import { VersionBadge } from '/snippets/version-badge.mdx' ## Starting a Server `fastmcp run` starts a server. Point it at a Python file, a factory function, a remote URL, or a config file: ```bash fastmcp run server.py fastmcp run server.py:create\_server fastmcp run https://example.com/mcp fastmcp run fastmcp.json ``... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/running.mdx | main | model-context-protocol-fastmcp | [
-0.03431444242596626,
0.013195417821407318,
-0.02738904021680355,
-0.056493133306503296,
-0.01735841855406761,
-0.08725656569004059,
-0.09809647500514984,
0.02520519122481346,
-0.02798963338136673,
-0.020011786371469498,
0.014444886706769466,
0.03430333361029625,
0.05077555403113365,
-0.00... | -0.037395 |
Apps `fastmcp dev apps` launches a browser-based preview UI for servers with [Prefab App tools](/apps/prefab). It starts your MCP server on one port and a local dev UI on another — giving you a live, interactive picker where you can call app tools and see their rendered output without needing a full MCP host client. ``... | https://github.com/jlowin/fastmcp/blob/main/docs/cli/running.mdx | main | model-context-protocol-fastmcp | [
-0.06682439148426056,
-0.05156305804848671,
0.01718781143426895,
0.018020685762166977,
0.018126627430319786,
-0.0360138937830925,
-0.08481911569833755,
0.02358565852046013,
0.004307164810597897,
-0.0029575880616903305,
0.02013862319290638,
-0.055534038692712784,
0.004720162600278854,
-0.00... | -0.016043 |
FastMCP uses [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic\_settings/) for configuration. Every setting is available as an environment variable with a `FASTMCP\_` prefix. Settings are loaded from environment variables and from a `.env` file (see the [Tasks (Docket)](#tasks-docket) section for a... | https://github.com/jlowin/fastmcp/blob/main/docs/more/settings.mdx | main | model-context-protocol-fastmcp | [
0.025961963459849358,
0.021232258528470993,
-0.03849377483129501,
-0.034305863082408905,
0.02880658023059368,
-0.10043315589427948,
-0.03544686734676361,
0.04548537731170654,
-0.018644079566001892,
0.0005931883351877332,
0.009294364601373672,
-0.059774093329906464,
0.05053415149450302,
-0.... | -0.082027 |
| `true` | When an `ExceptionGroup` is raised, re-raise the first error directly instead of the group. Simplifies debugging but may mask secondary errors. | ## CLI & Display | Environment Variable | Type | Default | Description | |---|---|---|---| | `FASTMCP\_SHOW\_SERVER\_BANNER` | `bool` | `true` | Show the server ba... | https://github.com/jlowin/fastmcp/blob/main/docs/more/settings.mdx | main | model-context-protocol-fastmcp | [
-0.022944007068872452,
0.042507465928792953,
0.034389395266771317,
0.03465649485588074,
0.044520072638988495,
-0.05253352224826813,
0.013774361461400986,
-0.020004089921712875,
-0.02569245733320713,
0.01314304769039154,
0.07432692497968674,
-0.059620682150125504,
0.08108813315629959,
-0.05... | 0.00562 |
## `import fastmcp` stopped working after I upgraded with pip This can happen when you upgrade to FastMCP 3.3 or later from FastMCP 3.2 or earlier with `pip`. The quick fix is `pip install --force-reinstall fastmcp`. See [Troubleshooting](/getting-started/installation#troubleshooting) for the clean-reinstall fallback a... | https://github.com/jlowin/fastmcp/blob/main/docs/more/faq.mdx | main | model-context-protocol-fastmcp | [
-0.041653357446193695,
-0.06445708125829697,
0.06143929809331894,
-0.04825981333851814,
0.07232613861560822,
-0.04810759425163269,
-0.05588172376155853,
0.016999537125229836,
-0.010761586017906666,
-0.05794389918446541,
0.06891238689422607,
-0.005539502948522568,
0.004087983630597591,
0.06... | -0.059502 |
\*\*[v2.14.7: Fake It Till You Break It](https://github.com/PrefectHQ/fastmcp/releases/tag/v2.14.7)\*\* A 2.x backport of the fakeredis pin: fakeredis 2.35.0 renamed a connection class that pydocket's `memory://` backend depended on, crashing `fastmcp[tasks]` installs at startup. This caps `fakeredis<2.35.0` on the 2.x... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/changelog.mdx | main | model-context-protocol-fastmcp | [
-0.09786645323038101,
0.0037078489549458027,
0.006900355219841003,
-0.07833028584718704,
0.07924272119998932,
-0.12133083492517471,
-0.005885748192667961,
0.04659116268157959,
-0.021420687437057495,
0.008181333541870117,
0.11016324907541275,
0.03171929717063904,
-0.001156612765043974,
0.01... | -0.024376 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.