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 |
|---|---|---|---|---|---|
are ephemeral (random salt at startup), so tokens are invalidated on restart. This automatic approach is convenient for development but not suitable for production deployments. \*\*For Production:\*\* Production requires explicit key management to ensure tokens survive restarts and can be shared across multiple server ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/http.mdx | main | model-context-protocol-fastmcp | [
-0.04746030271053314,
-0.06133045628666878,
-0.05619810149073601,
-0.011530626565217972,
0.00033504818566143513,
-0.06657572090625763,
0.03791298344731331,
0.06893433630466461,
0.0441504642367363,
-0.030654745176434517,
-0.015718426555395126,
-0.010570768266916275,
0.06049933284521103,
0.0... | 0.102877 |
FastMCP servers can be run in different ways depending on your needs. This guide focuses on running servers locally for development and testing. For production deployment to a URL, see the [HTTP Deployment](/v2/deployment/http) guide. ## The `run()` Method Every FastMCP server needs to be started to accept connections.... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/running-server.mdx | main | model-context-protocol-fastmcp | [
-0.05077695474028587,
-0.02099938876926899,
-0.015069246292114258,
0.0007901977514848113,
-0.053606066852808,
-0.0955706536769867,
-0.08549490571022034,
-0.0049264440312981606,
-0.025680039077997208,
-0.029519295319914818,
0.06761643290519714,
0.02652328461408615,
0.05726834014058113,
-0.0... | -0.032198 |
transport was the original HTTP-based transport for MCP. While still supported for backward compatibility, it has limitations compared to the newer Streamable HTTP transport. SSE only supports server-to-client streaming, making it less efficient for bidirectional communication. ```python if \_\_name\_\_ == "\_\_main\_\... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/running-server.mdx | main | model-context-protocol-fastmcp | [
-0.027487030252814293,
-0.047023214399814606,
0.006482836324721575,
0.025331467390060425,
-0.06009304150938988,
-0.06513108313083649,
-0.030654020607471466,
0.08184449374675751,
-0.05676022171974182,
-0.026549220085144043,
-0.06424394249916077,
-0.003939716145396233,
-0.0009633832960389555,
... | 0.109494 |
error about the event loop already running. Always use `run\_async()` inside async functions and `run()` in synchronous contexts. Both `run()` and `run\_async()` accept the same transport arguments, so all the examples above apply to both methods. ## Custom Routes When using HTTP transport, you might want to add custom... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/running-server.mdx | main | model-context-protocol-fastmcp | [
-0.034368984401226044,
0.0084129823371768,
-0.0048044114373624325,
0.053416766226291656,
-0.05022287368774414,
-0.054455529898405075,
-0.005813356954604387,
0.022803286090493202,
-0.02014525607228279,
-0.016528349369764328,
0.029414907097816467,
0.015615640208125114,
-0.0005724315415136516,
... | 0.0191 |
import { VersionBadge } from "/snippets/version-badge.mdx" FastMCP supports declarative configuration through `fastmcp.json` files. This is the canonical and preferred way to configure FastMCP projects, providing a single source of truth for server settings, dependencies, and deployment options that replaces complex co... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/server-configuration.mdx | main | model-context-protocol-fastmcp | [
-0.05678883567452431,
0.04244085028767586,
0.013446448370814323,
-0.08198447525501251,
0.03140777349472046,
-0.018232671543955803,
-0.06788891553878784,
-0.0036320944782346487,
-0.023261046037077904,
-0.06757824122905731,
0.04910632222890854,
0.027776487171649933,
0.0604514554142952,
-0.02... | 0.000132 |
`mcp`, `server`, or `app` \*\*Example:\*\* ```json "source": { "type": "filesystem", "path": "src/server.py", "entrypoint": "mcp" } ``` Note: File paths are resolved relative to the configuration file's location. \*\*Future Source Types\*\* Future releases will support additional source types: - \*\*Git repositories\*\... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/server-configuration.mdx | main | model-context-protocol-fastmcp | [
-0.08908572047948837,
-0.048047471791505814,
0.017633624374866486,
0.006328991148620844,
0.0044464245438575745,
-0.10222548246383667,
-0.06916215270757675,
0.06582919508218765,
0.0008135121897794306,
0.03270470350980759,
0.0061912741512060165,
0.023600826039910316,
0.04947283864021301,
-0.... | 0.05412 |
number for HTTP transport. URL path for the MCP endpoint when using HTTP transport. Server logging verbosity. Options: - `"DEBUG"`: Detailed debugging information - `"INFO"`: General informational messages - `"WARNING"`: Warning messages - `"ERROR"`: Error messages only - `"CRITICAL"`: Critical errors only Environment ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/server-configuration.mdx | main | model-context-protocol-fastmcp | [
0.020929740741848946,
-0.04095714911818504,
-0.05733116343617439,
0.023609044030308723,
-0.03676458075642586,
-0.05087124556303024,
0.015138981863856316,
0.05960429087281227,
0.0038100627716630697,
0.025503549724817276,
-0.05146811157464981,
-0.008866687305271626,
-0.03769814223051071,
-0.... | 0.021306 |
run fastmcp.json --skip-source ``` \*\*When you already have the source:\*\* - You've previously cloned a git repository and don't need to re-fetch - You have a cached copy of a cloud-hosted server - You're in a CI/CD pipeline where source checkout is a separate step - You're iterating locally on already-downloaded cod... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/server-configuration.mdx | main | model-context-protocol-fastmcp | [
-0.07021865993738174,
-0.017290962859988213,
0.02182278409600258,
-0.0012929548975080252,
0.03738640621304512,
-0.08124610036611557,
-0.0526689775288105,
-0.039491456001996994,
0.0210234634578228,
0.023764800280332565,
0.11002086848020554,
-0.021961720660328865,
0.029634995386004448,
-0.10... | -0.106412 |
"source": { "path": "server.py", "entrypoint": "mcp" }, "deployment": { "transport": "http", "log\_level": "DEBUG" } } ``` \*\*prod.fastmcp.json\*\*: ```json { "$schema": "https://gofastmcp.com/public/schemas/fastmcp.json/v1.json", "source": { "path": "server.py", "entrypoint": "mcp" }, "environment": { "requirements":... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/deployment/server-configuration.mdx | main | model-context-protocol-fastmcp | [
-0.014473510906100273,
0.027951207011938095,
-0.022812068462371826,
-0.05454987287521362,
0.05341954901814461,
-0.05534542351961136,
-0.02562348172068596,
0.02825453318655491,
-0.009542207233607769,
-0.003727075643837452,
0.09926677495241165,
-0.08910824358463287,
0.023693140596151352,
0.0... | -0.055315 |
You've built a powerful REST API, and now you want your LLM to be able to use it. Manually writing a wrapper function for every single endpoint is tedious, error-prone, and hard to maintain. This is where \*\*FastMCP\*\* shines. If your API has an OpenAPI (or Swagger) specification, FastMCP can automatically convert yo... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/tutorials/rest-api.mdx | main | model-context-protocol-fastmcp | [
-0.02869715727865696,
-0.04041886329650879,
0.02312583662569523,
-0.00847404170781374,
-0.0100413728505373,
-0.028749629855155945,
-0.11406072974205017,
0.04059919714927673,
-0.06436531990766525,
0.024989377707242966,
-0.012529609724879265,
-0.057506393641233444,
0.07272462546825409,
-0.02... | 0.117036 |
python api\_server.py ``` Then, in another terminal, run the client: ```bash python api\_client.py ``` You should see a list of generated tools (`get\_users`, `get\_user\_by\_id`) and the result of calling the `get\_user\_by\_id` tool, which fetches data from the live JSONPlaceholder API.  server in Python. The goal is to create a service that can provide tools and data to AI models like Claude, Gemini, or others that support the protocol. While the [MCP specification](https://modelcontextprotocol.io/specification/) is powerful, implementing it from scr... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/tutorials/create-mcp-server.mdx | main | model-context-protocol-fastmcp | [
-0.07557867467403412,
-0.03126390650868416,
-0.004082015715539455,
0.006850728299468756,
-0.07046898454427719,
-0.07859136909246445,
-0.01757967844605446,
0.030162861570715904,
-0.0492633692920208,
-0.018231580033898354,
-0.04310426115989685,
0.0074989632703363895,
0.048048969358205795,
-0... | 0.130919 |
MCP Server") @mcp.tool def add(a: int, b: int) -> int: """Adds two integer numbers together.""" return a + b @mcp.resource("resource://config") def get\_config() -> dict: """Provides the application's configuration.""" return {"version": "1.0", "author": "MyTeam"} @mcp.resource("greetings://{name}") def personalized\_g... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/tutorials/create-mcp-server.mdx | main | model-context-protocol-fastmcp | [
-0.08402327448129654,
0.06588264554738998,
0.035610198974609375,
0.012119506485760212,
-0.10635723173618317,
-0.06369150429964066,
0.06930767744779587,
0.025383276864886284,
0.000606238900218159,
-0.0852569192647934,
-0.017099158838391304,
-0.019595513120293617,
0.10997587442398071,
-0.021... | 0.048675 |
The Model Context Protocol (MCP) is an open standard designed to solve a fundamental problem in AI development: how can Large Language Models (LLMs) reliably and securely interact with external tools, data, and services? It's the \*\*bridge between the probabilistic, non-deterministic world of AI and the deterministic,... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/tutorials/mcp.mdx | main | model-context-protocol-fastmcp | [
-0.06676430255174637,
-0.06035556644201279,
0.04411671310663223,
-0.02895773947238922,
0.039173293858766556,
-0.016467895358800888,
-0.042370788753032684,
0.026535069569945335,
0.045362405478954315,
-0.01896033249795437,
-0.04815435782074928,
-0.056112855672836304,
0.06059947609901428,
0.0... | 0.274206 |
dict: """Returns the current operational status of the service.""" return {"status": "all systems normal"} ``` #### Resource Templates You can also create \*\*Resource Templates\*\* for dynamic data. A client could request `users://42/profile` to get the profile for a specific user. ```python from fastmcp import FastMC... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/tutorials/mcp.mdx | main | model-context-protocol-fastmcp | [
-0.0365847684442997,
0.06990968436002731,
-0.027917947620153427,
0.022154396399855614,
-0.05890046805143356,
-0.09729040414094925,
0.12534047663211823,
0.08228883892297745,
-0.04576895013451576,
-0.06719259172677994,
0.021863367408514023,
-0.0280006006360054,
0.08839336782693863,
0.0107860... | 0.012907 |
import { YouTubeEmbed } from '/snippets/youtube-embed.mdx' ## Join the Community Connect with other FastMCP developers, share your projects, and discuss ideas. ## Featured Projects Discover exemplary MCP servers and implementations created by our community. These projects demonstrate best practices and innovative uses ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/community/showcase.mdx | main | model-context-protocol-fastmcp | [
-0.08958044648170471,
-0.0940052792429924,
0.01748536340892315,
-0.04194101318717003,
0.007086039986461401,
-0.02674064226448536,
-0.034808456897735596,
-0.01687413826584816,
-0.055780041962862015,
-0.007536677177995443,
0.00601954385638237,
0.03925374522805214,
0.046521466225385666,
0.003... | 0.031842 |
import { VersionBadge } from '/snippets/version-badge.mdx' Tools are the core building blocks that allow your LLM to interact with external systems, execute code, and access data that isn't in its training data. In FastMCP, tools are Python functions exposed to LLMs through the MCP protocol. Tools in FastMCP transform ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.059229686856269836,
0.02127411589026451,
0.004243445582687855,
-0.03944733366370201,
0.03576663136482239,
-0.06601358205080032,
-0.025976596400141716,
-0.022292889654636383,
-0.03294986113905907,
-0.039091117680072784,
0.007772992365062237,
0.02589586190879345,
0.11112925410270691,
-0.0... | 0.059946 |
This data is passed through to the MCP client as the `\_meta` field of the client-side tool object and can be used for custom metadata, versioning, or other application-specific purposes. ### Async Support FastMCP is an async-first framework that seamlessly supports both asynchronous (`async def`) and synchronous (`def... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.07832114398479462,
0.048189181834459305,
-0.035719793289899826,
0.06843099743127823,
0.00010497186303837225,
-0.14767470955848694,
-0.006259733811020851,
-0.010663921944797039,
0.014006253331899643,
-0.02517007663846016,
0.018134314566850662,
0.0150986909866333,
-0.04599004611372948,
-0... | 0.115858 |
values | | Paths | `Path` | File system paths (auto-converted from strings) | | UUIDs | `UUID` | Universally unique identifiers (auto-converted from strings) | | Pydantic models | `UserData` | Complex structured data with validation | FastMCP supports all types that Pydantic supports as fields, including all Pydantic c... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.030368512496352196,
0.035198964178562164,
-0.06185377016663551,
-0.03782711923122406,
-0.0174478217959404,
-0.06753969192504883,
-0.0019429336534813046,
0.04332616925239563,
-0.0035078227519989014,
-0.025022000074386597,
0.020291928201913834,
-0.05467885732650757,
0.10679444670677185,
-... | -0.007034 |
#### Simple String Descriptions For basic parameter descriptions, you can use a convenient shorthand with `Annotated`: ```python from typing import Annotated @mcp.tool def process\_image( image\_url: Annotated[str, "URL of the image to process"], resize: Annotated[bool, "Whether to resize the image"] = False, width: An... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.010140429250895977,
0.08054359257221222,
0.014157670550048351,
0.009139453060925007,
0.013617715798318386,
-0.07795223593711853,
0.04723483324050903,
0.11700714379549026,
-0.06411430984735489,
-0.04388360306620598,
-0.007192492019385099,
-0.028087148442864418,
0.06229228526353836,
0.091... | 0.099154 |
Classes FastMCP provides helper classes for returning images, audio, and files. When you return one of these classes, either directly or as part of a list, FastMCP automatically converts it to the appropriate MCP content block. For example, if you return a `fastmcp.utilities.types.Image` object, FastMCP will convert it... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.04374731332063675,
-0.031735897064208984,
0.024690013378858566,
0.012552869506180286,
0.05513608828186989,
-0.05208107829093933,
-0.001926946104504168,
0.023446450009942055,
-0.020101120695471764,
-0.05266421660780907,
0.043610602617263794,
-0.020032135769724846,
0.07154936343431473,
0.... | 0.005587 |
...}` object, since JSON schemas require object-type roots for structured output: ```python Tool Definition @mcp.tool def calculate\_sum(a: int, b: int) -> int: """Calculate sum with return annotation.""" return a + b # Returns 8 ``` ```json MCP Result { "content": [ { "type": "text", "text": "8" } ], "structuredConten... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.06590911000967026,
0.055690255016088486,
0.008818835020065308,
0.019864017143845558,
-0.046833597123622894,
-0.02298392914235592,
-0.017206577584147453,
0.06104191765189171,
-0.0315084233880043,
-0.052946317940950394,
0.046447161585092545,
-0.057862624526023865,
0.012617560103535652,
0.... | 0.042114 |
display to users. Can be a string (automatically converted to `TextContent`), a list of MCP content blocks, or any serializable value (converted to JSON string). At least one of `content` or `structured\_content` must be provided. ```python # Simple string ToolResult(content="Hello, world!") # List of content blocks To... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.026730189099907875,
0.01202371995896101,
-0.05892983078956604,
0.036313436925411224,
-0.03808670490980148,
-0.048383861780166626,
0.006656718906015158,
0.10789218544960022,
-0.021749276667833328,
-0.060318972915410995,
0.08327621221542358,
-0.0803445428609848,
0.12307824939489365,
0.054... | 0.055453 |
dynamic\_tool.disable() dynamic\_tool.enable() ``` ## MCP Annotations FastMCP allows you to add specialized metadata to your tools through annotations. These annotations communicate how tools behave to client applications without consuming token context in LLM prompts. Annotations serve several purposes in client appli... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.08384273946285248,
0.03949972614645958,
-0.020977672189474106,
0.042509086430072784,
-0.035117264837026596,
-0.008334586396813393,
0.01871964894235134,
0.03177056089043617,
0.03692691773176193,
-0.01661018095910549,
-0.005146305076777935,
-0.10260292887687683,
0.053024716675281525,
-0.0... | 0.079194 |
manually polling for changes. ```python @mcp.tool def example\_tool() -> str: return "Hello!" # These operations trigger notifications: mcp.add\_tool(example\_tool) # Sends tools/list\_changed notification example\_tool.disable() # Sends tools/list\_changed notification example\_tool.enable() # Sends tools/list\_change... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tools.mdx | main | model-context-protocol-fastmcp | [
-0.058947719633579254,
-0.060977596789598465,
0.03419583663344383,
0.07956387847661972,
0.0034994480665773153,
-0.11333320289850235,
0.0606609545648098,
-0.029089370742440224,
0.044912245124578476,
0.036453258246183395,
-0.0032268899958580732,
0.012176726944744587,
0.032224420458078384,
-0... | 0.086235 |
import { VersionBadge } from "/snippets/version-badge.mdx" FastMCP uses pluggable storage backends for caching responses and managing OAuth state. By default, all storage is in-memory, which is perfect for development but doesn't persist across restarts. FastMCP includes support for multiple storage backends, and you c... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/storage-backends.mdx | main | model-context-protocol-fastmcp | [
-0.06527640670537949,
0.02189498208463192,
-0.032683003693819046,
-0.016695840284228325,
0.0052787852473556995,
-0.03414873033761978,
-0.03308812156319618,
0.0019840202294290066,
-0.013806503266096115,
-0.0035809348337352276,
0.038138385862112045,
0.051906879991292953,
0.09233370423316956,
... | 0.019242 |
and storage based on your platform: - \*\*Mac/Windows\*\*: Keys are auto-managed via system keyring, storage defaults to disk. Suitable \*\*only\*\* for development and local testing. - \*\*Linux\*\*: Keys are ephemeral, storage defaults to memory. No configuration needed: ```python from fastmcp.server.auth.providers.g... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/storage-backends.mdx | main | model-context-protocol-fastmcp | [
-0.04117446020245552,
-0.020347321406006813,
-0.11142139136791229,
0.01648891530930996,
-0.018367400392889977,
-0.031943704932928085,
0.020827967673540115,
0.023253293707966805,
0.030314723029732704,
0.04261909797787666,
0.10883966088294983,
0.01944238506257534,
0.07359987497329712,
-0.023... | 0.053298 |
import { VersionBadge } from "/snippets/version-badge.mdx" FastMCP implements the MCP background task protocol ([SEP-1686](https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/tasks)), giving your servers a production-ready distributed task scheduler with a single decorator change. \*\*What is Docke... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tasks.mdx | main | model-context-protocol-fastmcp | [
-0.051888737827539444,
0.034989748150110245,
0.037812698632478714,
-0.017567425966262817,
0.06413456797599792,
-0.07001422345638275,
-0.013932989910244942,
-0.04322382062673569,
0.05509145185351372,
0.06879324465990067,
-0.06573310494422913,
0.007767376024276018,
0.029573731124401093,
-0.0... | 0.167437 |
this with `task=False`. ```python mcp = FastMCP("MyServer", tasks=True) ``` If your server defines any synchronous tools, resources, or prompts, you will need to explicitly set `task=False` on their decorators to avoid an error. ### Graceful Degradation When a client requests background execution but the component has ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tasks.mdx | main | model-context-protocol-fastmcp | [
-0.014763767831027508,
0.031409576535224915,
0.02126895636320114,
0.04314267635345459,
0.017027152702212334,
-0.12121076881885529,
-0.059246473014354706,
-0.03102605789899826,
-0.011951017193496227,
-0.031217867508530617,
-0.01162034459412098,
0.014322841539978981,
0.055957894772291183,
-0... | -0.014303 |
retry policies, timeouts, and custom dependencies. | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/tasks.mdx | main | model-context-protocol-fastmcp | [
-0.07506946474313736,
0.015316072851419449,
0.07268814742565155,
0.0065275938250124454,
-0.0010069316485896707,
-0.011683824472129345,
-0.00556141184642911,
-0.04385397583246231,
-0.0511016845703125,
0.011816365644335747,
0.07036960870027542,
0.0774252638220787,
0.007967057637870312,
-0.02... | 0.046261 |
import { VersionBadge } from '/snippets/version-badge.mdx' User elicitation allows MCP servers to request structured input from users during tool execution. Instead of requiring all inputs upfront, tools can interactively ask for missing parameters, clarification, or additional context as needed. Most of the examples i... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/elicitation.mdx | main | model-context-protocol-fastmcp | [
-0.07900138199329376,
-0.002758946269750595,
0.04539317265152931,
-0.022416716441512108,
0.059994522482156754,
-0.02188940718770027,
0.0035842908546328545,
-0.0036289487034082413,
-0.05638284608721733,
-0.019868772476911545,
-0.0017050232272595167,
-0.057077836245298386,
0.09945318847894669,... | 0.136632 |
or no response at all, by automatically wrapping them in MCP-compatible object schemas. ### Scalar Types You can request simple scalar data types for basic 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... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/elicitation.mdx | main | model-context-protocol-fastmcp | [
-0.07858087122440338,
0.015389973297715187,
0.007654774468392134,
0.07577905803918839,
-0.09200969338417053,
-0.05799763649702072,
0.006249692291021347,
0.020213663578033447,
-0.0719037801027298,
-0.07815470546483994,
0.02963661402463913,
-0.09638005495071411,
0.014484122395515442,
0.03168... | 0.011095 |
list of strings" @mcp.tool async def select\_tags(ctx: Context) -> str: """Select multiple tags.""" result = await ctx.elicit( "Choose tags", response\_type=[["bug", "feature", "documentation"]] # Note: list of a list ) if result.action == "accept": tags = result.data # List of selected strings return f"Selected tags: ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/elicitation.mdx | main | model-context-protocol-fastmcp | [
-0.009208268485963345,
-0.006837939377874136,
0.010101070627570152,
0.0012465949403122067,
0.0723930299282074,
-0.04511209949851036,
0.12214773893356323,
0.04727521538734436,
-0.041899509727954865,
-0.0031292277853935957,
0.04999218136072159,
-0.09197307378053665,
0.02221916988492012,
-0.0... | 0.082327 |
= Field(default=Priority.MEDIUM, description="Task priority") @mcp.tool async def create\_task(ctx: Context) -> str: result = await ctx.elicit("Please provide task details", response\_type=TaskDetails) if result.action == "accept": return f"Created: {result.data.title}" return "Task creation cancelled" ``` ## Multi-Tur... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/elicitation.mdx | main | model-context-protocol-fastmcp | [
-0.033705901354551315,
0.021591883152723312,
0.009522730484604836,
0.0873672142624855,
-0.037195540964603424,
-0.05675775930285454,
-0.022755516692996025,
0.004500049166381359,
0.04383091628551483,
-0.02548569068312645,
-0.029137710109353065,
-0.07866597920656204,
-0.019547171890735626,
0.... | 0.075037 |
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/v2/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
-0.006977922283113003,
0.029025837779045105,
0.06271084398031235,
-0.05900561437010765,
0.05900908261537552,
-0.008885134942829609,
0.01643412746489048,
0.015947449952363968,
-0.017121758311986923,
-0.04281243681907654,
0.012758316472172737,
-0.037920501083135605,
0.1340133249759674,
-0.06... | 0.006829 |
as strings, but FastMCP allows you to use typed annotations for better developer experience. When you use complex types like `list[int]` or `dict[str, str]`, FastMCP: 1. \*\*Automatically converts\*\* string arguments from MCP clients to the expected types 2. \*\*Generates helpful descriptions\*\* showing the exact JSO... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
-0.04123444855213165,
0.0793609693646431,
0.04212479293346405,
0.004500895738601685,
-0.04332764819264412,
-0.09206883609294891,
0.06618279963731766,
0.04792537912726402,
0.014122246764600277,
-0.04835887625813484,
-0.016581591218709946,
-0.033497296273708344,
0.03184989467263222,
0.070550... | 0.058363 |
If `analysis\_type` or `include\_charts` are omitted, their default values will be used. ### Disabling Prompts You can control the visibility and availability of prompts by enabling or disabling them. Disabled prompts will not appear in the list of available prompts, and attempting to call a disabled prompt will result... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
0.014822079800069332,
0.018041839823126793,
0.03189297020435333,
0.07956526428461075,
0.04741979390382767,
0.003068641060963273,
-0.0227808877825737,
-0.02528860792517662,
-0.05662606284022331,
0.00614707637578249,
-0.004904316738247871,
-0.07642250508069992,
0.044465966522693634,
-0.00929... | -0.005948 |
`ValueError`, preventing the duplicate registration. - `"replace"`: Silently replaces the existing prompt with the new one. - `"ignore"`: Keeps the original prompt and ignores the new registration attempt. | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/prompts.mdx | main | model-context-protocol-fastmcp | [
-0.06589638441801071,
-0.029439473524689674,
0.03751664608716965,
-0.008345291949808598,
0.004537982866168022,
-0.05805836617946625,
0.06266624480485916,
0.00715820724144578,
0.014548802748322487,
-0.051750779151916504,
0.07234132289886475,
-0.024683766067028046,
0.08425389975309372,
-0.08... | -0.035856 |
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, sampl... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.05515148490667343,
-0.024935316294431686,
0.0012427468318492174,
-0.0464237779378891,
0.05127694457769394,
-0.05825844407081604,
-0.011067511513829231,
0.0076324655674397945,
0.017852574586868286,
-0.013448644429445267,
-0.06615971028804779,
-0.0022879750467836857,
0.099457748234272,
-0... | 0.075304 |
outputs, while lower values make responses more deterministic. The `max\_tokens` parameter limits response length. ### Model Preferences Model preferences let you hint at which LLM the client should use for a request. You can pass a single model name or a list of preferences in priority order. These are hints rather th... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.03771943598985672,
0.022959228605031967,
-0.010361419059336185,
0.12228047847747803,
-0.02895992621779442,
-0.08704061806201935,
-0.009243197739124298,
0.10890650004148483,
0.03522726148366928,
-0.03143880143761635,
-0.07211306691169739,
-0.05538339540362358,
0.038319382816553116,
-0.00... | 0.071137 |
using available tools.""" result = await ctx.sample( messages=question, tools=[search, get\_time], ) return result.text or "" ``` The LLM sees each function's signature and docstring, using this information to decide when and how to call them. Tool errors are caught and sent back to the LLM, allowing it to recover grac... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.02955646440386772,
0.07333619892597198,
-0.0005893840570934117,
0.04140201583504677,
0.019626272842288017,
-0.07252040505409241,
0.015207810327410698,
0.08209323137998581,
-0.00421995110809803,
-0.05226079002022743,
-0.03486105427145958,
-0.07695072144269943,
0.07896513491868973,
-0.046... | -0.015431 |
tool results, ready for the next iteration - \*\*`execute\_tools=False`\*\*: Includes the assistant's tool request, but you add results yourself ### Manual Tool Execution Set `execute\_tools=False` to handle tool execution yourself. When disabled, `step.history` contains the user message and the assistant's response wi... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/sampling.mdx | main | model-context-protocol-fastmcp | [
-0.06497518718242645,
0.030878212302923203,
-0.000041808380046859384,
0.0817161500453949,
-0.07111313939094543,
-0.040324289351701736,
0.002443560864776373,
0.011887816712260246,
-0.02138460986316204,
-0.0802825540304184,
0.062011051923036575,
-0.054816972464323044,
0.049757011234760284,
-... | -0.000238 |
import { VersionBadge } from "/snippets/version-badge.mdx" The central piece of a FastMCP application is the `FastMCP` server class. This class acts as the main container for your application's tools, resources, and prompts, and manages communication with MCP clients. ## Creating a Server Instantiating a server is stra... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/server.mdx | main | model-context-protocol-fastmcp | [
-0.06030449643731117,
0.007805234752595425,
0.021766038611531258,
-0.0218952726572752,
-0.02278689667582512,
-0.07998615503311157,
-0.0018315196502953768,
0.018255101516842842,
-0.03666752949357033,
-0.022868884727358818,
0.024873171001672745,
-0.016005143523216248,
0.08422835916280746,
-0... | 0.067835 |
```python @mcp.prompt def analyze\_data(data\_points: list[float]) -> str: """Creates a prompt asking for analysis of numerical data.""" formatted\_data = ", ".join(str(point) for point in data\_points) return f"Please analyze these data points: {formatted\_data}" ``` See [Prompts](/v2/servers/prompts) for detailed doc... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/server.mdx | main | model-context-protocol-fastmcp | [
-0.012867484241724014,
0.057919953018426895,
-0.031492508947849274,
0.032916802912950516,
0.0522097647190094,
-0.11520442366600037,
0.09297123551368713,
-0.02806047350168228,
-0.03752335533499718,
-0.037682171911001205,
0.04711401090025902,
-0.058920085430145264,
0.08798853307962418,
0.010... | -0.009203 |
reuse existing servers. See the [Server Composition](/v2/servers/composition) guide for full details, best practices, and examples. ```python # Example: Importing a subserver from fastmcp import FastMCP import asyncio main = FastMCP(name="Main") sub = FastMCP(name="Sub") @sub.tool def hello(): return "hi" # Mount direc... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/server.mdx | main | model-context-protocol-fastmcp | [
-0.0839366540312767,
-0.07139308005571365,
0.017505062744021416,
0.04112008213996887,
-0.11542317271232605,
-0.09794271737337112,
-0.0704924613237381,
0.025144504383206367,
-0.016888046637177467,
-0.0364585816860199,
-0.025448592379689217,
0.04197445884346962,
0.05265121906995773,
-0.03097... | 0.076293 |
`tool\_serializer` function when creating your server: ```python import yaml from fastmcp import FastMCP # Define a custom serializer that formats dictionaries as YAML def yaml\_serializer(data): return yaml.dump(data, sort\_keys=False) # Create a server with the custom serializer mcp = FastMCP(name="MyServer", tool\_s... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/server.mdx | main | model-context-protocol-fastmcp | [
-0.04301036521792412,
0.012503230012953281,
0.015213541686534882,
-0.00453746784478426,
-0.07606316357851028,
-0.061415985226631165,
-0.03990013152360916,
-0.00726647675037384,
0.02511337772011757,
-0.03642858564853668,
0.08303574472665787,
0.022464312613010406,
0.009387221187353134,
-0.07... | 0.011843 |
import { VersionBadge } from '/snippets/version-badge.mdx' Progress reporting allows MCP tools to notify clients about the progress of long-running operations. This enables clients to display progress indicators and provide better user experience during time-consuming tasks. ## Why Use Progress Reporting? Progress repo... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/progress.mdx | main | model-context-protocol-fastmcp | [
-0.06838510185480118,
0.06185024604201317,
-0.03368357568979263,
0.030503850430250168,
-0.0004668191249947995,
-0.022456614300608635,
-0.006401277147233486,
0.002177830319851637,
-0.03120153397321701,
-0.022546537220478058,
-0.0013164457632228732,
-0.008964979089796543,
0.05341679975390434,
... | 0.08102 |
Client Requirements Progress reporting requires clients to support progress handling: - Clients must send a `progressToken` in the initial request to receive progress updates - If no progress token is provided, progress calls will have no effect (they won't error) - See [Client Progress](/v2/clients/progress) for detai... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/progress.mdx | main | model-context-protocol-fastmcp | [
-0.05812012776732445,
0.00914946012198925,
0.0018999520689249039,
-0.013017882592976093,
-0.03604266792535782,
0.008338574320077896,
-0.07431154698133469,
-0.014724843204021454,
-0.01095847599208355,
0.011993078514933586,
-0.06101742759346962,
0.019685324281454086,
-0.0109889330342412,
0.0... | 0.047811 |
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. Ser... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/logging.mdx | main | model-context-protocol-fastmcp | [
-0.027119839563965797,
0.016792502254247665,
0.046001337468624115,
0.0044362205080688,
0.0911112055182457,
-0.0858093649148941,
0.009238671511411667,
0.0016168218571692705,
-0.017865994945168495,
0.02295536734163761,
0.015387580730021,
0.009169738739728928,
0.07124484330415726,
-0.03863441... | 0.071678 |
permissions") # File processing logic await ctx.debug("File processing completed successfully") return "File processed" ``` ### Info Use for general information about normal program execution: ```python @mcp.tool async def backup\_database(ctx: Context) -> str: """Backup database with progress information.""" await ctx... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/logging.mdx | main | model-context-protocol-fastmcp | [
-0.07078251242637634,
0.029918784275650978,
-0.061657730489969254,
0.041521355509757996,
-0.006875231396406889,
-0.09465645253658295,
-0.016008678823709488,
0.03885580226778984,
-0.10246898978948593,
-0.0005725487717427313,
0.0013009097892791033,
0.010432190261781216,
0.0853782594203949,
-... | 0.007885 |
import { VersionBadge } from "/snippets/version-badge.mdx" MCP middleware is a powerful concept that allows you to add cross-cutting functionality to your FastMCP server. Unlike traditional web middleware, MCP middleware is designed specifically for the Model Context Protocol, providing hooks for different types of MCP... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.09673547744750977,
-0.009967654012143612,
0.08279892802238464,
-0.085647813975811,
0.10349330306053162,
-0.025052955374121666,
-0.04331449046730995,
0.0014806251274421811,
-0.04761683940887451,
0.0131043940782547,
-0.018792325630784035,
-0.004819199908524752,
0.0619618259370327,
-0.0296... | 0.174527 |
the raw `\_\_call\_\_` method, you can override specific hook methods that are called only for certain types of operations, allowing you to target exactly the level of specificity you need for your middleware logic. ### Hook Hierarchy and Execution Order FastMCP provides multiple hooks that are called with varying leve... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.04088887944817543,
-0.018099121749401093,
0.07725924253463745,
-0.045265428721904755,
0.018622057512402534,
-0.07764189690351486,
0.05892089381814003,
0.030787307769060135,
-0.004437502473592758,
0.016137849539518356,
-0.024809757247567177,
-0.05160769075155258,
0.028724566102027893,
-0... | 0.173903 |
To handle this in middleware, check if the MCP request context is available before accessing MCP-specific attributes. Note that the MCP request context is distinct from the HTTP request - for HTTP transports, you can use HTTP helpers to access request data even when the MCP session is not available: ```python from fast... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.0739913284778595,
0.04853041470050812,
0.037556059658527374,
-0.03682766854763031,
0.045048486441373825,
-0.07814793288707733,
0.06541774421930313,
0.017931697890162468,
-0.01489670667797327,
-0.005987916141748428,
-0.003407868091017008,
-0.06388795375823975,
0.017208218574523926,
0.014... | 0.029844 |
await call\_next(context) # Filter out tools with "private" tag filtered\_tools = [ tool for tool in result if "private" not in tool.tags ] # Return modified list return filtered\_tools ``` This filtering happens before the components are converted to MCP format and returned to the client. Tags are accessible both duri... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.1059408038854599,
0.07065124809741974,
-0.0010431993287056684,
0.016862990334630013,
0.07378922402858734,
-0.0854596421122551,
0.030876869335770607,
0.004658398684114218,
0.001845475402660668,
-0.017617572098970413,
0.04594040289521217,
-0.03551986813545227,
0.06798011064529419,
-0.0348... | -0.014972 |
your tools can (optionally) access later. To do so, use the FastMCP Context to either `set\_state` or `get\_state` as appropriate. For more information, see the [Context State Management](/v2/servers/context#state-management) docs. ## Creating Middleware FastMCP middleware is implemented by subclassing the `Middleware`... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.06669536978006363,
-0.005874409340322018,
0.0055469018407166,
0.005604414734989405,
0.031975097954273224,
-0.08283203095197678,
0.025530938059091568,
0.009946947917342186,
-0.022177889943122864,
0.02525346353650093,
-0.0010031522251665592,
-0.03916407376527786,
0.043428897857666016,
-0.... | 0.11729 |
tools into the server during the request lifecycle: ```python from fastmcp.server.middleware.tool\_injection import ToolInjectionMiddleware def my\_tool\_fn(a: int, b: int) -> int: return a + b my\_tool = Tool.from\_function(fn=my\_tool\_fn, name="my\_tool") mcp.add\_middleware(ToolInjectionMiddleware(tools=[my\_tool])... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.08769795298576355,
-0.02602233551442623,
-0.009613892063498497,
-0.05504979193210602,
0.02711258828639984,
-0.06745412945747375,
0.02739226073026657,
0.03604487329721451,
-0.010823315940797329,
0.007467607501894236,
0.00712153734639287,
-0.04652150347828865,
0.07755535840988159,
-0.0117... | 0.107826 |
time from collections import defaultdict from fastmcp.server.middleware import Middleware, MiddlewareContext from mcp import McpError from mcp.types import ErrorData class SimpleRateLimitMiddleware(Middleware): def \_\_init\_\_(self, requests\_per\_minute: int = 60): self.requests\_per\_minute = requests\_per\_minute s... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/middleware.mdx | main | model-context-protocol-fastmcp | [
-0.061227355152368546,
0.049292825162410736,
0.038203317672014236,
-0.022339237853884697,
0.023704273626208305,
-0.12039662152528763,
0.017950376495718956,
0.003649554681032896,
0.0021456419490277767,
-0.005962369032204151,
0.028408370912075043,
-0.03733988478779793,
0.01948915235698223,
-... | 0.037937 |
import { VersionBadge } from '/snippets/version-badge.mdx' As your MCP applications grow, you might want to organize your tools, resources, and prompts into logical modules or reuse existing server components. FastMCP supports composition through two methods: - \*\*`import\_server`\*\*: For a one-time copy of component... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/composition.mdx | main | model-context-protocol-fastmcp | [
-0.04895445704460144,
-0.050197482109069824,
0.05447375029325485,
-0.0054694474674761295,
0.020844195038080215,
-0.039794858545064926,
-0.061051204800605774,
-0.00840455200523138,
-0.0491887629032135,
0.011886890977621078,
0.003496376797556877,
-0.019636016339063644,
0.07868975400924683,
-... | 0.029351 |
Name: `template.name` becomes `"{prefix}\_{template.name}"`. 4. \*\*Prompts\*\*: All prompts are added with names prefixed using `{prefix}\_`. - `subserver.prompt(name="my\_prompt")` becomes `main\_mcp.prompt(name="{prefix}\_my\_prompt")`. Note that `import\_server` performs a \*\*one-time copy\*\* of components. Chang... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/composition.mdx | main | model-context-protocol-fastmcp | [
-0.022291451692581177,
-0.04834135249257088,
0.04373864084482193,
-0.01009487546980381,
-0.020278144627809525,
-0.0862647071480751,
-0.009497091174125671,
0.03892172500491142,
-0.018231067806482315,
-0.027747953310608864,
0.02251468412578106,
-0.025722645223140717,
0.06246329843997955,
-0.... | 0.024979 |
this slowdown affects the whole server, not just interactions with the HTTP-proxied tools. If performance is important, importing tools via [`import\_server()`](#importing-static-composition) may be a more appropriate solution as it copies components once at startup rather than delegating requests at runtime. #### Moun... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/composition.mdx | main | model-context-protocol-fastmcp | [
-0.04081331938505173,
-0.02597024291753769,
0.07240961492061615,
0.0008731470443308353,
0.0018667581025511026,
-0.09457498788833618,
-0.08440009504556656,
-0.029586374759674072,
0.012923412024974823,
-0.008905628696084023,
0.05946265906095505,
0.03740726411342621,
0.058592308312654495,
0.0... | -0.077089 |
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/v2/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 |
value into the appropriate MCP resource content: - \*\*`str`\*\*: Sent as `TextResourceContents` (with `mime\_type="text/plain"` by default). - \*\*`dict`, `list`, `pydantic.BaseModel`\*\*: Automatically serialized to a JSON string and sent as `TextResourceContents` (with `mime\_type="application/json"` by default). - ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.03286514803767204,
0.04655613377690315,
-0.024982338771224022,
0.05885712802410126,
0.02814403735101223,
-0.07072124630212784,
0.03131987899541855,
0.07404109835624695,
0.015993036329746246,
-0.012355709448456764,
0.014292099513113499,
-0.01076006330549717,
0.05189377814531326,
0.067036... | 0.047614 |
text/binary modes and lazy reading. - `HttpResource`: Fetches content from an HTTP(S) URL (requires `httpx`). - `DirectoryResource`: Lists files in a local directory (returns JSON). - (`FunctionResource`: Internal class used by `@mcp.resource`). Use these when the content is static or sourced directly from a file/URL, ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.07996945083141327,
0.025006618350744247,
0.021020950749516487,
0.07133983075618744,
-0.025349808856844902,
-0.07377304136753082,
-0.00264124502427876,
0.09425662457942963,
-0.03365976735949516,
-0.02185923606157303,
0.026823105290532112,
0.031157145276665688,
0.06759694963693619,
0.0203... | 0.016773 |
set of parameters, which means that resources can be dynamically created on-demand. For example, if the resource template `"user://profile/{name}"` is registered, MCP clients could request `"user://profile/ford"` or `"user://profile/marvin"` to retrieve either of those two user profiles as resources, without having to ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.10231859236955643,
0.05472922697663307,
0.0295335054397583,
0.05616692081093788,
-0.06056799367070198,
-0.0476086251437664,
0.05618295073509216,
-0.011584920808672905,
-0.013048247434198856,
-0.08670416474342346,
-0.03099742904305458,
-0.07135070860385895,
0.0921051949262619,
0.01837912... | -0.008735 |
provide a clean way to pass optional configuration to resources without cluttering the path. Query parameters must be optional function parameters (have default values), while path parameters map to required function parameters. This enforces a clear separation: required data goes in the path, optional configuration in... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.05572986230254173,
0.0897940844297409,
0.029620986431837082,
0.04563077539205551,
-0.0699673444032669,
-0.02716558799147606,
0.005756172817200422,
0.04318375885486603,
-0.010765976272523403,
-0.08380493521690369,
0.04372403025627136,
-0.04191260784864426,
0.07101695239543915,
0.00851514... | -0.048885 |
powerful way to expose parameterized data access points following REST-like principles. ## Error Handling If your resource function encounters an error, you can raise a standard Python exception (`ValueError`, `TypeError`, `FileNotFoundError`, custom exceptions, etc.) or a FastMCP `ResourceError`. By default, all excep... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.03321215510368347,
0.11724202334880829,
0.007746019400656223,
0.044609032571315765,
-0.008530167862772942,
-0.05393648520112038,
0.012927187606692314,
0.05241333693265915,
-0.021550163626670837,
-0.03287879750132561,
0.0025763986632227898,
-0.07925526797771454,
0.1567966192960739,
-0.03... | -0.015183 |
import { VersionBadge } from '/snippets/version-badge.mdx' FastMCP provides a powerful proxying capability that allows one FastMCP server instance to act as a frontend for another MCP server (which could be remote, running on a different transport, or even another FastMCP instance). This is achieved using the `FastMCP.... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/proxy.mdx | main | model-context-protocol-fastmcp | [
-0.07148770987987518,
-0.020548485219478607,
0.0710364282131195,
-0.05658380687236786,
-0.017441099509596825,
-0.010105843655765057,
0.00019817777501884848,
-0.0380389429628849,
0.004712420515716076,
-0.04459759220480919,
-0.019114170223474503,
0.009259586222469807,
0.060356732457876205,
-... | 0.05123 |
- Client B calls a tool -> gets different isolated backend session # - No context mixing between requests ``` ### Session Reuse with Connected Clients When you pass an already-connected client, the proxy will reuse that session for all requests: ```python from fastmcp import Client # Create and connect a client async w... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/proxy.mdx | main | model-context-protocol-fastmcp | [
-0.10071596503257751,
-0.026127969846129417,
-0.026126598939299583,
0.016550514847040176,
-0.10429559648036957,
-0.05283195897936821,
0.05447327718138695,
-0.00016518363554496318,
0.014924369752407074,
-0.031975071877241135,
-0.050530608743429184,
0.025615885853767395,
0.06290247291326523,
... | 0.016438 |
may evolve as the specification matures. While FastMCP aims to maintain compatibility with future versions, be aware that field names or structure might change. ### Multi-Server Configurations You can create a proxy to multiple servers by specifying multiple entries in the config. They are automatically mounted with th... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/proxy.mdx | main | model-context-protocol-fastmcp | [
-0.08330654352903366,
-0.006868848577141762,
0.06314373016357422,
0.060834988951683044,
-0.05593116953969002,
-0.09193748235702515,
-0.061514440923929214,
-0.047697633504867554,
-0.01294556725770235,
-0.028283128514885902,
-0.05762417986989021,
-0.047798771411180496,
0.06703704595565796,
0... | -0.019394 |
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/v2/servers/icons.mdx | main | model-context-protocol-fastmcp | [
-0.008890832774341106,
0.034760862588882446,
0.06321790814399719,
-0.0015195122687146068,
0.04173260182142258,
-0.04384385794401169,
0.010065045207738876,
0.004381007514894009,
-0.021260669454932213,
-0.021938633173704147,
-0.003910026513040066,
0.046789612621068954,
0.07613664865493774,
-... | 0.013179 |
import { VersionBadge } from '/snippets/version-badge.mdx' When defining FastMCP [tools](/v2/servers/tools), [resources](/v2/servers/resources), resource templates, or [prompts](/v2/servers/prompts), your functions might need to interact with the underlying MCP session or access advanced server capabilities. FastMCP pr... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.04549214988946915,
0.05507688596844673,
0.05513321980834007,
-0.03408142551779747,
0.07813107222318649,
-0.034147653728723526,
-0.0010696297977119684,
-0.004682132508605719,
-0.029799483716487885,
-0.019460145384073257,
0.006047413684427738,
-0.02206634171307087,
0.02585720270872116,
-0... | 0.04599 |
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") @mcp.tool async def analyze\_dataset(dataset\_name: str) -> ... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.10156372934579849,
0.03252943605184555,
-0.04758307710289955,
0.0541718527674675,
-0.015266469679772854,
-0.16303488612174988,
0.11311189830303192,
0.021560877561569214,
-0.02136821858584881,
-0.05043913051486015,
0.05954862758517265,
-0.050650618970394135,
0.01736612804234028,
-0.02765... | 0.061212 |
data storage across requests, use external storage mechanisms like databases, files, or in-memory caches. This simplified example shows how to use MCP middleware to store user info in the context state, and how to access that state in a tool: ```python {7-8, 16-17} from fastmcp.server.middleware import Middleware, Midd... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.0691579133272171,
0.01856391318142414,
-0.07112152129411697,
-0.0016427983064204454,
-0.0353764183819294,
-0.07341382652521133,
0.0638207346200943,
0.07206887006759644,
-0.012942005880177021,
-0.008271051570773125,
0.005781511776149273,
-0.014802346006035805,
0.05684661120176315,
-0.040... | 0.088674 |
# Check if MCP session is available if ctx.request\_context: # MCP session available - can access MCP-specific attributes return { "session\_id": ctx.session\_id, "request\_id": ctx.request\_id, "has\_meta": ctx.request\_context.meta is not None } else: # MCP session not available - use HTTP helpers for request data (i... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.011698559857904911,
0.0669780969619751,
-0.002134152688086033,
-0.027269503101706505,
0.02237105555832386,
-0.05419030785560608,
0.10195080935955048,
0.03382861241698265,
-0.04376029595732689,
-0.0002079666592180729,
-0.027310429140925407,
-0.08172234892845154,
0.010410626418888569,
0.0... | 0.061471 |
@mcp.tool async def get\_user\_info() -> dict: """Get information about the authenticated user.""" # Get the access token (None if not authenticated) token: AccessToken | None = get\_access\_token() if token is None: return {"authenticated": False} return { "authenticated": True, "client\_id": token.client\_id, "scopes... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.04497327655553818,
0.06457442790269852,
-0.04801332950592041,
0.03680112957954407,
0.017404776066541672,
-0.06862416863441467,
0.04883860796689987,
0.01235488522797823,
-0.03542876988649368,
-0.0030945343896746635,
0.02081083133816719,
-0.05663318186998367,
-0.013296130113303661,
-0.059... | 0.052521 |
documentation on dependencies](https://chrisguidry.github.io/docket/dependencies/) for details. | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/context.mdx | main | model-context-protocol-fastmcp | [
-0.02203894592821598,
0.010543121956288815,
0.02458229474723339,
-0.05102289468050003,
0.036432232707738876,
-0.0046838922426104546,
-0.017992902547121048,
0.032473959028720856,
-0.007904618047177792,
-0.012418079189956188,
-0.0268360935151577,
-0.010118401609361172,
-0.07800883054733276,
... | 0.081466 |
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/v2/servers/auth/full-oauth-server.mdx | main | model-context-protocol-fastmcp | [
-0.07814939320087433,
0.061523985117673874,
0.06154279038310051,
-0.08227232843637466,
0.06214230880141258,
-0.035014595836400986,
0.019691182300448418,
-0.01404789462685585,
-0.027890082448720932,
-0.06053571775555611,
0.035056907683610916,
0.01711595058441162,
0.10680948942899704,
-0.026... | -0.038848 |
and secure storage requirements. Mistakes can lead to serious security vulnerabilities. | https://github.com/jlowin/fastmcp/blob/main//docs/v2/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/v2/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/v2/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/v2/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 |
Each provider has its own configuration options set through environment variables: ```bash # JWT Token Verification export FASTMCP\_SERVER\_AUTH=fastmcp.server.auth.providers.jwt.JWTVerifier export FASTMCP\_SERVER\_AUTH\_JWT\_JWKS\_URI="https://auth.example.com/jwks" export FASTMCP\_SERVER\_AUTH\_JWT\_ISSUER="https://a... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/auth/authentication.mdx | main | model-context-protocol-fastmcp | [
-0.06734130531549454,
-0.010900365188717842,
-0.0015967022627592087,
-0.03142658993601799,
-0.0230589397251606,
-0.08039122074842453,
0.00831124372780323,
0.02022434212267399,
-0.0388619601726532,
-0.04149078205227852,
0.04455579072237015,
-0.07981465756893158,
0.07323244214057922,
-0.0439... | -0.048521 |
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/v2/servers/auth/oidc-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.12929117679595947,
0.017774883657693863,
-0.003623472759500146,
-0.027071353048086166,
0.03315262496471405,
-0.03934485837817192,
-0.0010446531232446432,
-0.03163391351699829,
0.028116170316934586,
-0.030864737927913666,
0.0030624319333583117,
0.04334603250026703,
0.07056991010904312,
-... | -0.081235 |
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/v2/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/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.11483585089445114,
-0.008671351708471775,
0.08420347422361374,
-0.05346809700131416,
0.040098924189805984,
-0.017679424956440926,
-0.03742974251508713,
0.0011904881102964282,
0.04749628156423569,
0.002944200299680233,
-0.005807868205010891,
0.0415981188416481,
0.08793981373310089,
-0.01... | -0.059493 |
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/v2/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](/v2/servers/storage-backends) for available options. \*\*When providing custom storage\*\*, wrap it in `FernetEncryptionWrapper` to encrypt sensitive OAuth tokens at rest: ```pyth... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.03779172524809837,
0.01740523800253868,
-0.08999397605657578,
0.02518486976623535,
0.005097555462270975,
-0.09103886783123016,
0.014340043067932129,
0.07739560306072235,
0.06291291862726212,
-0.028880344703793526,
-0.03530663996934891,
-0.018189286813139915,
0.051128093153238297,
-0.015... | 0.042997 |
verifiers like `GitHubTokenVerifier` See the [Token Verification guide](/v2/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 fo... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.07599114626646042,
-0.001947419485077262,
0.004849945195019245,
0.03146921098232269,
-0.025825191289186478,
-0.1345858871936798,
0.029328538104891777,
0.05829182267189026,
-0.023326823487877846,
-0.07485300302505493,
-0.06946340948343277,
0.01829340122640133,
0.10637283325195312,
0.0087... | 0.020849 |
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/v2/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/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.06561560183763504,
0.03705902397632599,
0.016940735280513763,
-0.004381225444376469,
0.0374397411942482,
-0.05039746314287186,
0.04893139749765396,
0.05563449114561081,
0.05962406471371651,
-0.023563271388411522,
-0.002030137460678816,
0.006578934378921986,
0.09273866564035416,
0.019489... | 0.060504 |
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/v2/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/v2/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/v2/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 |
str) -> bool: # Check if token exists in Redis, database, etc. return await redis.exists(f"valid\_tokens:{token}") verifier = DebugTokenVerifier( validate=validate\_token, client\_id="api-client", scopes=["api:access"] ) mcp = FastMCP(name="Custom API", auth=verifier) ``` \*\*Use Cases:\*\* - \*\*Testing\*\*: Accept an... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/auth/token-verification.mdx | main | model-context-protocol-fastmcp | [
-0.09438850730657578,
0.01014709286391735,
-0.0036780897062271833,
0.016410935670137405,
0.014911588281393051,
-0.10759180039167404,
0.02301674149930477,
0.04927124083042145,
0.016553303226828575,
-0.01978401094675064,
0.031837038695812225,
-0.0743844285607338,
0.06140044704079628,
-0.0279... | 0.171747 |
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/v2/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/v2/servers/auth/remote-oauth.mdx | main | model-context-protocol-fastmcp | [
-0.131194606423378,
0.01334443036466837,
0.07691458612680435,
-0.025559725239872932,
0.08696402609348297,
-0.03855064511299133,
0.021004505455493927,
-0.006550474092364311,
0.054452456533908844,
-0.02271966263651848,
0.058943502604961395,
0.021508021280169487,
0.07279316335916519,
-0.01497... | 0.030018 |
routes, then adds additional endpoints as needed. A common use case is providing authorization server metadata forwarding, which allows MCP clients to discover your identity provider's capabilities through your MCP server rather than contacting the identity provider directly. ## WorkOS AuthKit Integration WorkOS AuthKi... | https://github.com/jlowin/fastmcp/blob/main//docs/v2/servers/auth/remote-oauth.mdx | main | model-context-protocol-fastmcp | [
-0.09254074841737747,
0.024105899035930634,
0.013993622735142708,
-0.016459807753562927,
0.033157434314489365,
-0.08233143389225006,
0.028549250215291977,
0.04442905634641647,
0.0029565664008259773,
-0.028247566893696785,
0.007166392635554075,
-0.028783317655324936,
0.03231942281126976,
0.... | 0.106276 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using \*\*OCI IAM OAuth\*\*. Since OCI IAM doesn't support Dynamic Client Registration, this integration uses the [\*\*OIDC Proxy\*\*](/servers/auth/oidc-proxy) pattern to bridge OCI's traditional OAuth wit... | https://github.com/jlowin/fastmcp/blob/main//docs/integrations/oci.mdx | main | model-context-protocol-fastmcp | [
-0.1019369587302208,
0.05537024885416031,
0.017232481390237808,
-0.04028434306383133,
0.005068425554782152,
-0.08338722586631775,
0.01883031614124775,
-0.0005573437083512545,
0.04736834764480591,
-0.028178509324789047,
0.008615280501544476,
-0.05461626872420311,
0.096302330493927,
-0.06012... | -0.010589 |
have created a token exchange OAuth client. In most cases, you can use the same OAuth client that you created above. Replace `` and `` in the CLI command below with your actual values. ```bash oci identity-domains identity-propagation-trust create \ --schemas '["urn:ietf:params:scim:schemas:oracle:idcs:IdentityPropagat... | https://github.com/jlowin/fastmcp/blob/main//docs/integrations/oci.mdx | main | model-context-protocol-fastmcp | [
-0.06258055567741394,
0.02169262059032917,
-0.020744217559695244,
-0.06614572554826736,
0.03348498418927193,
-0.09562678635120392,
0.08072305470705032,
0.06795468926429749,
0.04080386832356453,
0.006498315837234259,
-0.02578108198940754,
-0.12001612037420273,
0.06588109582662582,
0.0175889... | -0.002724 |
storage backend like Redis for distributed deployments. For complete details on these parameters, see the [OAuth Proxy documentation](/servers/auth/oauth-proxy#configuration-parameters). The client caches tokens locally, so you won't need to re-authenticate for subsequent runs unless the token expires or you explicitly... | https://github.com/jlowin/fastmcp/blob/main//docs/integrations/oci.mdx | main | model-context-protocol-fastmcp | [
-0.02450750395655632,
-0.005181565415114164,
-0.032426852732896805,
0.037571508437395096,
-0.03741850703954697,
-0.08342709392309189,
-0.010760633274912834,
0.009373236447572708,
0.04416066035628319,
-0.02407751977443695,
-0.031156253069639206,
0.13442444801330566,
0.05359770730137825,
-0.... | 0.045392 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.