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 |
|---|---|---|---|---|---|
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 |
used by `@mcp.resource`). Use these when the content is static or sourced directly from a file/URL, bypassing the need for a dedicated Python function. ### Notifications FastMCP automatically sends `notifications/resources/list\_changed` notifications to connected clients when resources or templates are added, enabled,... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.10398852825164795,
-0.011967863887548447,
0.05453594774007797,
0.07220835238695145,
0.06372087448835373,
-0.08242791146039963,
0.08515409380197525,
-0.011332210153341293,
0.06492938101291656,
-0.012743636034429073,
0.026278192177414894,
0.039014335721731186,
0.06397192925214767,
-0.0017... | 0.202915 |
a specific city.""" # In a real implementation, this would call a weather API # Here we're using simplified logic for example purposes return { "city": city.capitalize(), "temperature": 22, "condition": "Sunny", "unit": "celsius" } # Template with multiple parameters and annotations @mcp.resource( "repos://{owner}/{rep... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.06439769268035889,
0.12119334936141968,
0.05050219967961311,
0.036662016063928604,
0.019580552354454994,
-0.12056002020835876,
0.04799816757440567,
-0.02519276551902294,
-0.004038660321384668,
-0.036447178572416306,
-0.011128322221338749,
-0.06440232694149017,
0.029659319669008255,
0.03... | 0.070081 |
"version": version, "limit": limit, "offset": offset, "results": fetch\_results(endpoint, version, limit, offset) } # Query parameters with wildcards @mcp.resource("files://{path\*}{?encoding,lines}") def read\_file(path: str, encoding: str = "utf-8", lines: int = 100) -> str: """Read file with optional encoding and li... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.07316074520349503,
0.05014663189649582,
-0.001941259135492146,
0.004865020513534546,
-0.05280984565615654,
-0.044512975960969925,
-0.013343065045773983,
0.06986528635025024,
-0.036712706089019775,
-0.041445959359407425,
0.023178929463028908,
0.039660751819610596,
0.06671598553657532,
-0... | 0.00781 |
FastMCP from fastmcp.exceptions import ResourceError mcp = FastMCP(name="DataServer") @mcp.resource("resource://safe-error") def fail\_with\_details() -> str: """This resource provides detailed error information.""" # ResourceError contents are always sent back to clients, # regardless of mask\_error\_details setting r... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/resources.mdx | main | model-context-protocol-fastmcp | [
-0.08215699344873428,
0.08797390013933182,
0.0498887300491333,
0.041980206966400146,
0.05969076603651047,
-0.08650525659322739,
0.028454575687646866,
-0.008275003172457218,
0.01089987251907587,
-0.02786180190742016,
0.08001918345689774,
-0.06144438683986664,
0.12037777900695801,
-0.0435222... | -0.01419 |
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 |
header (most common) - `"client\_secret\_post"`: Send credentials in request body (required by some providers) - `"none"`: No authentication (for public clients) - `None` (default): Uses authlib's default (typically `"client\_secret\_basic"`) Set this if your provider requires a specific authentication method and the d... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oidc-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.13237525522708893,
0.01653858833014965,
-0.02168111503124237,
-0.03923086076974869,
-0.0065347133204340935,
-0.026693953201174736,
0.039613720029592514,
0.040554918348789215,
0.03691679984331131,
-0.020856183022260666,
0.06926796585321426,
-0.0231313519179821,
0.03631627932190895,
-0.03... | 0.111501 |
the provider implementation export FASTMCP\_SERVER\_AUTH=fastmcp.server.auth.providers.auth0.Auth0Provider # Provider-specific credentials export FASTMCP\_SERVER\_AUTH\_AUTH0\_CONFIG\_URL=https://.../.well-known/openid-configuration export FASTMCP\_SERVER\_AUTH\_AUTH0\_CLIENT\_ID=tv2ObNgaZAWWhhycr7Bz1LU2mxlnsmsB export... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oidc-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.0643010288476944,
0.046888455748558044,
-0.06128234788775444,
-0.021017124876379967,
-0.016635604202747345,
-0.07261743396520615,
-0.0018561757169663906,
0.00694355508312583,
0.005760590545833111,
-0.04226386174559593,
0.05600879341363907,
-0.06729797273874283,
0.06699889153242111,
-0.0... | -0.063029 |
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 |
protected resource metadata and token audience. Use this when your OAuth callbacks and operational endpoints need to live under one public URL, but the protected MCP resource should be advertised under another. FastMCP will still append the MCP mount path (for example, `/mcp`) to this base URL. Path for OAuth callbacks... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.05669797956943512,
0.0022444382775574923,
0.03646550327539444,
0.030568931251764297,
0.010979239828884602,
-0.09063922613859177,
-0.030481383204460144,
0.01065172627568245,
0.05213741585612297,
-0.04518216848373413,
0.03995586186647415,
0.0057826656848192215,
0.0749242827296257,
0.01121... | -0.029579 |
the filesystem remains accessible. This means MCP clients only need to register once and can reconnect seamlessly. The disk store is encrypted using a key derived from the JWT Signing Key (which is derived from the upstream client secret by default). For client registrations to survive upstream client secret rotation, ... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.05962017923593521,
-0.01897185854613781,
-0.018421132117509842,
0.041357506066560745,
0.008649075403809547,
-0.034982550889253616,
-0.0067903222516179085,
0.10550928115844727,
0.05168084055185318,
-0.0045481654815375805,
0.014263820834457874,
0.05573272705078125,
0.06478137522935867,
-0... | 0.011927 |
you fully control all connecting clients. Content Security Policy for the consent page. - `None` (default): Uses the built-in CSP policy with appropriate directives for form submission - Empty string `""`: Disables CSP entirely (no meta tag rendered) - Custom string: Uses the provided value as the CSP policy This is us... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.07268080860376358,
0.11706902831792831,
-0.04103784263134003,
0.022390997037291527,
-0.00819080974906683,
-0.016149237751960754,
-0.021719880402088165,
-0.006740788463503122,
0.02946561388671398,
-0.01623576320707798,
0.00191121909301728,
-0.02082419954240322,
0.09230923652648926,
-0.02... | -0.01397 |
client stores these credentials believing it has registered a new app. Meanwhile, the proxy records the client's callback URL for later use. ### Authorization Phase The client initiates OAuth by redirecting to the proxy's `/authorize` endpoint. The proxy: 1. Stores the client's transaction with its PKCE challenge 2. Ge... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.14898481965065002,
0.06216510385274887,
0.0010701598366722465,
-0.019872281700372696,
-0.058140505105257034,
-0.022339915856719017,
0.039196908473968506,
0.05448620021343231,
0.09420691430568695,
-0.01872539147734642,
-0.09650776535272598,
0.041496943682432175,
0.0560697466135025,
-0.05... | -0.010613 |
disable it for legacy providers that don't support PKCE: ```python # Disable PKCE forwarding only if upstream doesn't support it auth = OAuthProxy( ..., forward\_pkce=False # Default is True ) ``` ### Redirect URI Validation While the OAuth proxy accepts all redirect URIs by default (for DCR compatibility), you can res... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.08464822173118591,
0.06711025536060333,
-0.013133171014487743,
-0.021532472223043442,
-0.018587570637464523,
-0.07940567284822464,
-0.06976158916950226,
0.039448853582143784,
-0.014948022551834583,
-0.028140950947999954,
-0.09410425275564194,
0.00021793435735162348,
0.033963970839977264,
... | -0.071795 |
server between an MCP client and a legitimate proxy: a malicious MCP server advertises its own authorization server, which redirects the victim's browser into the legitimate proxy's `/authorize` endpoint. Because the victim's browser carries the prior-approval cookie throughout, a `"remember"`-mode proxy would silently... | https://github.com/jlowin/fastmcp/blob/main/docs/v2/servers/auth/oauth-proxy.mdx | main | model-context-protocol-fastmcp | [
-0.040072835981845856,
0.01849708892405033,
-0.020085155963897705,
0.027160733938217163,
0.021698513999581337,
-0.025949928909540176,
0.07867883145809174,
-0.056491419672966,
0.018846042454242706,
0.027102183550596237,
0.015932852402329445,
0.003275081980973482,
0.05143607035279274,
0.0306... | 0.070096 |
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 |
import { VersionBadge } from "/snippets/version-badge.mdx" Google's Gemini API includes built-in support for MCP servers in their Python and JavaScript SDKs, allowing you to connect directly to MCP servers and use their tools seamlessly with Gemini models. ## Gemini Python SDK Google's [Gemini Python SDK](https://ai.go... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/gemini.mdx | main | model-context-protocol-fastmcp | [
-0.138987734913826,
-0.05415216460824013,
0.04691895842552185,
-0.045630890876054764,
0.012022418901324272,
-0.040434032678604126,
-0.022475697100162506,
-0.0118084866553545,
-0.05989345535635948,
-0.023000439628958702,
-0.03898222744464874,
0.04517567157745361,
0.060417987406253815,
-0.07... | 0.01317 |
import { VersionBadge } from "/snippets/version-badge.mdx" Install auth stack to your FastMCP server with [Scalekit](https://scalekit.com) using the [Remote OAuth](/servers/auth/remote-oauth) pattern: Scalekit handles user authentication, and the MCP server validates issued tokens. ### Prerequisites Before you begin 1.... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/scalekit.mdx | main | model-context-protocol-fastmcp | [
-0.026349801570177078,
0.009261632338166237,
0.028078531846404076,
-0.03414227440953255,
0.04076626896858215,
-0.021702080965042114,
-0.06330598890781403,
0.00414083618670702,
-0.032477039843797684,
-0.0011507674353197217,
0.05353297293186188,
-0.0728173479437828,
0.07515708357095718,
-0.0... | -0.063596 |
verification (already verified by provider) claims = jwt.decode(token, options={"verify\_signature": False}) return claims return {"error": "No token found"} ``` | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/scalekit.mdx | main | model-context-protocol-fastmcp | [
-0.13484196364879608,
0.04847356304526329,
0.040463849902153015,
0.016705691814422607,
0.02972421981394291,
-0.07199054211378098,
0.045602358877658844,
0.009409180842339993,
0.0009819489205256104,
-0.050170741975307465,
0.00861804187297821,
-0.060441240668296814,
0.04896050691604614,
0.016... | 0.006533 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using WorkOS's \*\*AuthKit\*\*, a complete authentication and user management solution. This integration uses the [\*\*Remote OAuth\*\*](/servers/auth/remote-oauth) pattern with [RFC 8707](https://www.rfc-e... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/authkit.mdx | main | model-context-protocol-fastmcp | [
-0.07749702781438828,
0.070366770029068,
0.01714436709880829,
-0.06850890070199966,
0.0649900808930397,
-0.033291805535554886,
0.010282725095748901,
-0.05754321441054344,
-0.008173187263309956,
-0.02769256755709648,
0.04375295341014862,
-0.05215099826455116,
0.05182604491710663,
0.03349757... | 0.012661 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using \*\*Supabase Auth\*\*. This integration uses the [\*\*Remote OAuth\*\*](/servers/auth/remote-oauth) pattern, where Supabase handles user authentication and your FastMCP server validates the tokens. Su... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/supabase.mdx | main | model-context-protocol-fastmcp | [
-0.06302167475223541,
0.03012421540915966,
0.04995438829064369,
-0.036509107798337936,
0.08800004422664642,
0.007793737109750509,
-0.013274077326059341,
-0.027293996885418892,
-0.016879945993423462,
-0.042362030595541,
0.03468627855181694,
-0.022061878815293312,
0.11714954674243927,
-0.012... | -0.003641 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using \*\*GitHub OAuth\*\*. Since GitHub doesn't support Dynamic Client Registration, this integration uses the [\*\*OAuth Proxy\*\*](/servers/auth/oauth-proxy) pattern to bridge GitHub's traditional OAuth ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/github.mdx | main | model-context-protocol-fastmcp | [
-0.05550466105341911,
-0.002512982813641429,
0.00901913270354271,
-0.04197109863162041,
0.00767518812790513,
-0.0034207699354737997,
-0.028286390006542206,
-0.002182002877816558,
-0.00245660706423223,
-0.03973076492547989,
0.03603949025273323,
-0.011447342112660408,
0.13119088113307953,
-0... | -0.064898 |
tokens locally, so you won't need to re-authenticate for subsequent runs unless the token expires or you explicitly clear the cache. ## Production Configuration For production deployments with persistent token management across server restarts, configure `jwt\_signing\_key` and `client\_storage`: ```python server.py im... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/github.mdx | main | model-context-protocol-fastmcp | [
-0.08281686156988144,
-0.016286306083202362,
-0.06303996592760086,
0.02950943075120449,
0.0037791836075484753,
-0.0673174187541008,
-0.004081031307578087,
0.052467215806245804,
0.026447277516126633,
-0.022262010723352432,
0.03476148471236229,
0.019011080265045166,
0.02302900329232216,
-0.0... | 0.068558 |
import { VersionBadge } from "/snippets/version-badge.mdx" import { LocalFocusTip } from "/snippets/local-focus.mdx" [Claude Desktop](https://www.claude.com/download) supports MCP servers through local STDIO connections and remote servers (beta), allowing you to extend Claude's capabilities with custom tools, resources... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/claude-desktop.mdx | main | model-context-protocol-fastmcp | [
-0.01923266239464283,
-0.055515263229608536,
-0.02652941271662712,
-0.07133156061172485,
-0.0033829230815172195,
0.05087732896208763,
-0.043554991483688354,
0.03031095489859581,
-0.05264437571167946,
-0.005942150484770536,
0.004628670401871204,
0.011157024651765823,
0.0549137145280838,
-0.... | -0.008077 |
with. This is particularly useful when your server requires a specific Python version: ```bash fastmcp install claude-desktop server.py --python 3.11 ``` \*\*Project directory\*\*: Use `--project` to run your server within a specific project directory. This ensures that `uv` will discover all `pyproject.toml`, `uv.toml... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/claude-desktop.mdx | main | model-context-protocol-fastmcp | [
-0.024227488785982132,
0.01232299953699112,
-0.016855880618095398,
-0.07406832277774811,
0.014511912129819393,
-0.0818188413977623,
-0.043290045112371445,
0.036129940301179886,
0.01914934441447258,
-0.020701054483652115,
0.046701911836862564,
-0.006605255417525768,
0.036568593233823776,
0.... | -0.10349 |
"your-api-key", "DEBUG": "true" } } } } ``` Claude Desktop runs servers in a completely isolated environment with no access to your shell environment or locally installed applications. You must explicitly pass any environment variables your server needs. ## Remote Servers Users on Claude Pro, Max, Team, and Enterprise ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/claude-desktop.mdx | main | model-context-protocol-fastmcp | [
-0.02184869535267353,
0.010440529324114323,
-0.02409624122083187,
-0.04568329080939293,
-0.08050885051488876,
-0.054911717772483826,
-0.047545235604047775,
0.07206758856773376,
-0.021834975108504295,
0.00849889311939478,
0.00819072313606739,
-0.015999428927898407,
0.061831727623939514,
-0.... | -0.068111 |
import { VersionBadge } from "/snippets/version-badge.mdx" ## Responses API OpenAI's [Responses API](https://platform.openai.com/docs/api-reference/responses) supports [MCP servers](https://platform.openai.com/docs/guides/tools-remote-mcp) as remote tool sources, allowing you to extend AI capabilities with custom funct... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/openai.mdx | main | model-context-protocol-fastmcp | [
-0.07636682689189911,
-0.029720652848482132,
0.006205146200954914,
0.02466217800974846,
0.05629871413111687,
-0.05093957856297493,
-0.01861513778567314,
-0.021153118461370468,
0.0343167670071125,
0.015359939076006413,
-0.007924310863018036,
-0.009896091185510159,
0.06151333078742027,
-0.02... | 0.111612 |
to sign and verify tokens. ```python from fastmcp.server.auth.providers.jwt import RSAKeyPair key\_pair = RSAKeyPair.generate() access\_token = key\_pair.create\_token(audience="dice-server") ``` FastMCP's `RSAKeyPair` utility is for development and testing only. Next, we'll create a `JWTVerifier` to authenticate the s... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/openai.mdx | main | model-context-protocol-fastmcp | [
-0.09140327572822571,
0.00476790638640523,
-0.03815216198563576,
-0.02258990705013275,
-0.02966357208788395,
-0.034683603793382645,
0.020210877060890198,
0.03220805525779724,
0.03007056750357151,
-0.08622447401285172,
0.013768887147307396,
-0.02326904609799385,
0.08204620331525803,
-0.0599... | -0.033835 |
import { VersionBadge } from "/snippets/version-badge.mdx"; This guide shows you how to secure your FastMCP server using [\*\*Descope\*\*](https://www.descope.com), a complete authentication and user management solution. This integration uses the [\*\*Remote OAuth\*\*](/servers/auth/remote-oauth) pattern, where Descope... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/descope.mdx | main | model-context-protocol-fastmcp | [
-0.08873801678419113,
0.03244127705693245,
0.003376659471541643,
-0.0731145367026329,
0.012568086385726929,
-0.009474363178014755,
-0.020583176985383034,
-0.019192513078451157,
-0.006741922348737717,
-0.03499244898557663,
0.05012563243508339,
-0.03781098499894142,
0.10998553037643433,
-0.0... | -0.037206 |
Add \*\*policy-based authorization\*\* to your FastMCP servers with one-line code addition with the \*\*[Eunomia][eunomia-github] authorization middleware\*\*. Control which tools, resources and prompts MCP clients can view and execute on your server. Define dynamic JSON-based policies and obtain a comprehensive audit ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/eunomia-authorization.mdx | main | model-context-protocol-fastmcp | [
-0.060922592878341675,
0.023448802530765533,
-0.008539176546037197,
-0.03349727764725685,
0.0023076559882611036,
-0.05245572328567505,
0.05124901607632637,
-0.010207177139818668,
-0.004391294438391924,
0.03566068410873413,
0.01732858084142208,
-0.041227780282497406,
0.07078025490045547,
-0... | 0.150619 |
import { VersionBadge } from "/snippets/version-badge.mdx" import { LocalFocusTip } from "/snippets/local-focus.mdx" [Cursor](https://www.cursor.com/) supports MCP servers through multiple transport methods including STDIO, SSE, and Streamable HTTP, allowing you to extend Cursor's AI assistant with custom tools, resour... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/cursor.mdx | main | model-context-protocol-fastmcp | [
-0.09088379889726639,
-0.06232322379946709,
0.023218220099806786,
-0.0712810605764389,
-0.030856870114803314,
-0.04222556948661804,
0.017056353390216827,
-0.02785651572048664,
-0.02235586568713188,
-0.013501262292265892,
0.03966723009943962,
-0.012166204862296581,
0.09229016304016113,
-0.0... | -0.001859 |
fastmcp install cursor server.py --project /path/to/my-project ``` #### Environment Variables Cursor runs servers in a completely isolated environment with no access to your shell environment or locally installed applications. You must explicitly pass any environment variables your server needs. If your server needs en... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/cursor.mdx | main | model-context-protocol-fastmcp | [
-0.05315084010362625,
-0.0020134001970291138,
0.02616514079272747,
-0.07663273811340332,
-0.012743981555104256,
-0.07043096423149109,
-0.029425833374261856,
0.032207589596509933,
-0.0393495075404644,
0.006485545076429844,
0.04080424830317497,
-0.0629747286438942,
0.07860344648361206,
0.009... | -0.090379 |
The 6 was a nice high roll there! The AI assistant can now access all the tools, resources, and prompts you've defined in your FastMCP server. | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/cursor.mdx | main | model-context-protocol-fastmcp | [
-0.09066808223724365,
-0.04017195105552673,
-0.015796508640050888,
-0.015218187123537064,
0.01972457952797413,
0.05013938620686531,
-0.03403729945421219,
-0.026305852457880974,
-0.017523784190416336,
0.01090754009783268,
0.03311767429113388,
0.01971268467605114,
-0.02095155231654644,
-0.09... | 0.122434 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using \*\*Keycloak OAuth\*\*. This integration uses the [\*\*Remote OAuth\*\*](/servers/auth/remote-oauth) pattern with Dynamic Client Registration (DCR), where Keycloak handles user login and your FastMCP ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/keycloak.mdx | main | model-context-protocol-fastmcp | [
-0.08896733820438385,
0.014932496473193169,
-0.0062517342157661915,
-0.0641026422381401,
-0.015673860907554626,
-0.008655796758830547,
-0.046490628272295,
-0.058254923671483994,
-0.005681329406797886,
0.0011226516216993332,
0.07523557543754578,
-0.017720231786370277,
0.09930816292762756,
-... | -0.097123 |
import { VersionBadge } from '/snippets/version-badge.mdx' FastMCP provides two powerful ways to integrate with FastAPI applications: 1. \*\*[Generate an MCP server FROM your FastAPI app](#generating-an-mcp-server)\*\* - Convert existing API endpoints into MCP tools 2. \*\*[Mount an MCP server INTO your FastAPI app](#m... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/fastapi.mdx | main | model-context-protocol-fastmcp | [
-0.05242941156029701,
0.006570523604750633,
0.03344094380736351,
-0.027974093332886696,
0.06628185510635376,
-0.07950600236654282,
-0.0827375277876854,
-0.038775503635406494,
-0.02242644503712654,
-0.06219547986984253,
0.01814279332756996,
-0.05553208291530609,
0.0682782456278801,
-0.07410... | 0.042261 |
defined from fastmcp import FastMCP # Convert to MCP server mcp = FastMCP.from\_fastapi(app=app) if \_\_name\_\_ == "\_\_main\_\_": mcp.run() ``` ### Adding Components Your converted MCP server is a full FastMCP instance, meaning you can add new tools, resources, and other components to it just like you would with any ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/fastapi.mdx | main | model-context-protocol-fastmcp | [
-0.03367381542921066,
-0.02833622321486473,
-0.030728457495570183,
-0.014187870547175407,
-0.04047688469290733,
-0.011136455461382866,
0.04454577714204788,
0.062146324664354324,
-0.03611813858151436,
-0.06989120692014694,
0.05573437735438347,
-0.051942553371191025,
0.09830285608768463,
-0.... | -0.021397 |
MCP server, you can use the `http\_app` method on your FastMCP instance. This will return an ASGI application that can be mounted to your FastAPI application. ```python {23-30} from fastmcp import FastMCP from fastapi import FastAPI # Create MCP server mcp = FastMCP("Analytics Tools") @mcp.tool def analyze\_pricing(cat... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/fastapi.mdx | main | model-context-protocol-fastmcp | [
-0.06549408286809921,
0.04682306945323944,
-0.09246402233839035,
0.06599204242229462,
-0.04867894947528839,
-0.07235349714756012,
0.019883448258042336,
0.022827142849564552,
0.03607410192489624,
-0.04138946905732155,
0.05041772872209549,
-0.11276988685131073,
0.049643490463495255,
-0.05175... | 0.020116 |
yield print("Shutting down the app...") # Create MCP server mcp = FastMCP("Tools") mcp\_app = mcp.http\_app(path="/") # Combine both lifespans app = FastAPI(lifespan=combine\_lifespans(app\_lifespan, mcp\_app.lifespan)) app.mount("/mcp", mcp\_app) # MCP endpoint at /mcp ``` `combine\_lifespans` enters lifespans in orde... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/fastapi.mdx | main | model-context-protocol-fastmcp | [
-0.05928734689950943,
0.04402221739292145,
-0.020689327269792557,
0.01892530545592308,
-0.030949613079428673,
-0.1527830958366394,
-0.11511196941137314,
0.0698619857430458,
-0.05791165307164192,
-0.02059226855635643,
0.06805048882961273,
-0.04266517609357834,
0.07728146761655807,
-0.062469... | 0.072003 |
[Pydantic AI](https://ai.pydantic.dev/) ships a [`FastMCPToolset`](https://ai.pydantic.dev/mcp/fastmcp-client/) that lets a Pydantic AI agent call tools exposed by any MCP server through the [FastMCP Client](/clients/client). Because the toolset is built on the FastMCP Client, it works with FastMCP servers as well as a... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/pydantic-ai.mdx | main | model-context-protocol-fastmcp | [
-0.09856545180082321,
-0.03826014697551727,
-0.06158354878425598,
-0.010041465982794762,
-0.04846319556236267,
-0.0768725797533989,
0.0005938782123848796,
0.029995160177350044,
0.02266532927751541,
-0.02451726235449314,
0.0019489600090309978,
-0.0321124903857708,
0.03621107339859009,
-0.03... | 0.155247 |
see [Token Verification](/servers/auth/token-verification). | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/pydantic-ai.mdx | main | model-context-protocol-fastmcp | [
-0.04049437865614891,
-0.01190780196338892,
-0.06152518838644028,
-0.04847103729844093,
0.03998447582125664,
-0.07397916167974472,
0.05741288512945175,
-0.0393795482814312,
0.011272970587015152,
-0.011053820140659809,
0.017448091879487038,
0.028166459873318672,
0.0543183796107769,
0.029383... | 0.193791 |
import { VersionBadge } from "/snippets/version-badge.mdx" Secure your FastMCP server with WorkOS Connect authentication. This integration uses the OAuth Proxy pattern to handle authentication through WorkOS Connect while maintaining compatibility with MCP clients. This guide covers WorkOS Connect applications. For Dyn... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/workos.mdx | main | model-context-protocol-fastmcp | [
-0.090369313955307,
0.04739789664745331,
0.007424010895192623,
-0.056651145219802856,
0.015076203271746635,
-0.0444902703166008,
-0.0265334639698267,
0.013621486723423004,
-0.035430364310741425,
-0.03478461503982544,
0.02915283851325512,
-0.03733133524656296,
0.049122508615255356,
0.012340... | 0.031612 |
variables and use a persistent storage backend like Redis for distributed deployments. For complete details on these parameters, see the [OAuth Proxy documentation](/servers/auth/oauth-proxy#configuration-parameters). ## Configuration Options WorkOS OAuth application client ID WorkOS OAuth application client secret You... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/workos.mdx | main | model-context-protocol-fastmcp | [
-0.01890292763710022,
0.07408112287521362,
-0.03613676130771637,
-0.01639666222035885,
-0.03584904968738556,
-0.08147110044956207,
-0.021956786513328552,
0.02090415358543396,
0.03844435513019562,
-0.04384119436144829,
0.026057342067360878,
0.020378023386001587,
0.06846030056476593,
-0.0490... | 0.003067 |
[ChatGPT](https://chatgpt.com/) supports MCP servers through remote HTTP connections in two modes: \*\*Chat mode\*\* for interactive conversations and \*\*Deep Research mode\*\* for comprehensive information retrieval. \*\*Developer Mode Required for Chat Mode\*\*: To use MCP servers in regular ChatGPT conversations, y... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/chatgpt.mdx | main | model-context-protocol-fastmcp | [
-0.07844896614551544,
-0.07255329936742783,
0.03519365191459656,
0.03373906388878822,
-0.023782048374414444,
-0.13556289672851562,
0.027272721752524376,
-0.013280906714498997,
0.0189556572586298,
-0.01694733276963234,
0.015591083094477654,
0.023794572800397873,
-0.0015690164873376489,
0.00... | 0.130694 |
"Jane Doe", "date": "2024"} } ``` ### Using Deep Research 1. Ensure your server is added to ChatGPT's connectors (same as Chat mode) 2. Start a new chat 3. Click \*\*+\*\* → \*\*Deep Research\*\* 4. Select your MCP server as a source 5. Ask research questions ChatGPT will use your `search` and `fetch` tools to find and... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/chatgpt.mdx | main | model-context-protocol-fastmcp | [
-0.05901535972952843,
-0.04009014368057251,
0.1080755740404129,
0.021915236487984657,
-0.0032297614961862564,
0.049628645181655884,
0.005353846121579409,
0.016286032274365425,
0.01255394984036684,
0.04071775823831558,
0.0025688940659165382,
-0.047840870916843414,
-0.07640806585550308,
-0.0... | 0.063554 |
import { VersionBadge } from "/snippets/version-badge.mdx" import { LocalFocusTip } from "/snippets/local-focus.mdx" [Claude Code](https://docs.anthropic.com/en/docs/claude-code) supports MCP servers through multiple transport methods including STDIO, SSE, and HTTP, allowing you to extend Claude's capabilities with cus... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/claude-code.mdx | main | model-context-protocol-fastmcp | [
-0.03935456648468971,
-0.040051043033599854,
-0.0029668514616787434,
-0.042632296681404114,
-0.03666813671588898,
-0.05232354998588562,
0.014144162647426128,
-0.019411234185099602,
-0.022287601605057716,
0.007603534497320652,
0.056184716522693634,
0.015520821325480938,
0.08260297030210495,
... | -0.005655 |
control over the configuration, you can manually use Claude Code's built-in MCP management commands. This gives you direct control over how your server is launched: ```bash # Add a server with custom configuration claude mcp add dice-roller -- uv run --with fastmcp fastmcp run server.py # Add with environment variables... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/claude-code.mdx | main | model-context-protocol-fastmcp | [
-0.04442291706800461,
-0.018288884311914444,
-0.01944267936050892,
-0.013729396276175976,
-0.04518651217222214,
-0.056654445827007294,
-0.056422311812639236,
0.05230644717812538,
-0.063860684633255,
0.01693475805222988,
0.02433583326637745,
-0.031196510419249535,
0.06629674136638641,
-0.02... | -0.04439 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using \*\*Google OAuth\*\*. Since Google doesn't support Dynamic Client Registration, this integration uses the [\*\*OAuth Proxy\*\*](/servers/auth/oauth-proxy) pattern to bridge Google's traditional OAuth ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/google.mdx | main | model-context-protocol-fastmcp | [
-0.11271131038665771,
0.019836511462926865,
0.08382914960384369,
-0.07564549893140793,
-0.007928302511572838,
0.0035793341230601072,
0.01476838905364275,
-0.042286843061447144,
-0.031794473528862,
-0.025139009580016136,
0.007724348455667496,
-0.0423923060297966,
0.11332210153341293,
-0.068... | -0.123463 |
the protected tool result = await client.call\_tool("get\_user\_info") print(f"Google user: {result['email']}") print(f"Name: {result['name']}") if \_\_name\_\_ == "\_\_main\_\_": asyncio.run(main()) ``` When you run the client for the first time: 1. Your browser will open to Google's authorization page 2. Sign in with... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/google.mdx | main | model-context-protocol-fastmcp | [
-0.11107103526592255,
0.044189080595970154,
-0.020926157012581825,
0.032166488468647,
-0.0609949566423893,
-0.11627961695194244,
0.016357971355319023,
0.0292530320584774,
-0.049075011163949966,
-0.046408891677856445,
0.008927005343139172,
0.022665591910481453,
0.020899759605526924,
-0.0788... | 0.020738 |
import { VersionBadge } from '/snippets/version-badge.mdx' FastMCP can automatically generate an MCP server from any OpenAPI specification, allowing AI models to interact with existing APIs through the MCP protocol. Instead of manually creating tools and resources, you provide an OpenAPI spec and FastMCP intelligently ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/openapi.mdx | main | model-context-protocol-fastmcp | [
-0.07989415526390076,
-0.00875937007367611,
0.04791887477040291,
-0.01722894236445427,
0.04936408996582031,
-0.055227864533662796,
-0.09956934303045273,
-0.015146570280194283,
-0.020481973886489868,
-0.02700735628604889,
-0.04010893031954765,
-0.050277866423130035,
0.08175202459096909,
-0.... | 0.081504 |
routes will be assigned to the first matching custom map. For example, prior to FastMCP 2.8.0, GET requests were automatically mapped to `Resource` and `ResourceTemplate` components based on whether they had path parameters. (This was changed solely for client compatibility reasons.) You can restore this behavior by pr... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/openapi.mdx | main | model-context-protocol-fastmcp | [
-0.0330674983561039,
0.02644786797463894,
0.06555429846048355,
0.06788673251867294,
-0.0507877841591835,
-0.033970512449741364,
-0.024340307340025902,
-0.0015340126119554043,
-0.046074263751506805,
-0.03989145904779434,
0.000026136087399208918,
-0.04300656542181969,
0.007787534035742283,
0... | 0.002023 |
even if they're POST elif route.path.startswith("/users/") and route.method == "POST": return MCPType.RESOURCE\_TEMPLATE # Use defaults for all other routes return None mcp = FastMCP.from\_openapi( openapi\_spec=spec, client=client, route\_map\_fn=custom\_route\_mapper, ) ``` ## Customization ### Component Names FastMC... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/openapi.mdx | main | model-context-protocol-fastmcp | [
-0.00750645762309432,
0.003549211658537388,
0.01772666908800602,
0.057193417102098465,
-0.01732003688812256,
-0.04339797794818878,
-0.014692369848489761,
0.028790341690182686,
-0.036655694246292114,
-0.07962744683027267,
0.029969068244099617,
-0.06217699125409126,
0.021300483494997025,
-0.... | 0.048659 |
customization, you can provide a `mcp\_component\_fn` when creating the MCP server. After each MCP component has been created, this function is called on it and has the opportunity to modify it in-place. Your `mcp\_component\_fn` is expected to modify the component in-place, not to return a new component. The result of... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/openapi.mdx | main | model-context-protocol-fastmcp | [
-0.013209620490670204,
0.017330307513475418,
0.03656788915395737,
0.06199472397565842,
0.010317869484424591,
-0.03382987901568413,
-0.023659784346818924,
0.015316559001803398,
0.002556183375418186,
-0.026762569323182106,
0.02482995018362999,
-0.006710627116262913,
-0.01335746981203556,
-0.... | -0.025687 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using \*\*Azure OAuth\*\* (Microsoft Entra ID). Since Azure doesn't support Dynamic Client Registration, this integration uses the [\*\*OAuth Proxy\*\*](/servers/auth/oauth-proxy) pattern to bridge Azure's ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/azure.mdx | main | model-context-protocol-fastmcp | [
-0.0866280123591423,
0.04017341509461403,
0.02697484940290451,
-0.02919568493962288,
-0.02053009904921055,
0.042056821286678314,
0.012964551337063313,
-0.06114858761429787,
0.012179999612271786,
0.02224491536617279,
0.02939552813768387,
-0.03923341631889343,
0.11965718120336533,
-0.0150484... | -0.055309 |
- \*\*Client Secret\*\*: The value you copied in the previous step Store these credentials securely. Never commit them to version control. Use environment variables or a secrets manager in production. ### Step 2: FastMCP Configuration Create your FastMCP server using the `AzureProvider`, which handles Azure's OAuth flo... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/azure.mdx | main | model-context-protocol-fastmcp | [
-0.08401471376419067,
0.06605208665132523,
-0.027452383190393448,
0.002714637666940689,
-0.01500382088124752,
0.006417862139642239,
-0.006349239964038134,
-0.01952170766890049,
0.06554162502288818,
0.0685032457113266,
0.05379704013466835,
-0.026683203876018524,
0.10261356085538864,
0.01146... | -0.138963 |
run server.py --transport http --port 8000 ``` Your server is now running and protected by Azure OAuth authentication. ### Testing with a Client Create a test client that authenticates with your Azure-protected server: ```python test\_client.py from fastmcp import Client import asyncio async def main(): # The client wi... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/azure.mdx | main | model-context-protocol-fastmcp | [
-0.06189395859837532,
0.039261866360902786,
-0.055757246911525726,
0.051359400153160095,
-0.03006214275956154,
-0.07031649351119995,
-0.007095934357494116,
-0.04399511590600014,
0.02541111409664154,
0.012998176738619804,
0.042896997183561325,
-0.0028697631787508726,
0.030742352828383446,
0... | -0.068575 |
a new token that can call other services, maintaining the user's identity and permissions throughout the chain. This pattern is useful when your tools need to access user-specific data from Microsoft services: reading emails, accessing calendar events, querying SharePoint, or any other Graph API operation that requires... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/azure.mdx | main | model-context-protocol-fastmcp | [
-0.06048724427819252,
0.011109177954494953,
-0.06622263789176941,
0.008830844424664974,
-0.03492109477519989,
-0.04747960343956947,
0.06764126569032669,
0.002467276994138956,
-0.017274219542741776,
0.0836944505572319,
-0.0157172828912735,
-0.05579859018325806,
0.0005897970986552536,
0.1175... | 0.05833 |
a complete working example of Azure OBO with FastMCP, see [Pamela Fox's blog post on OBO flow for Entra-based MCP servers](https://blog.pamelafox.org/2026/01/using-on-behalf-of-flow-for-entra-based.html). ## Azure AD B2C Azure AD B2C (Business-to-Consumer) uses different endpoints, scope URIs, and token issuers than st... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/azure.mdx | main | model-context-protocol-fastmcp | [
-0.07315836101770401,
-0.024861382320523262,
-0.04872696101665497,
0.004634603392332792,
-0.01735050044953823,
-0.050285663455724716,
0.054582081735134125,
-0.02183840610086918,
-0.02236330695450306,
0.06710422039031982,
0.005169662181288004,
-0.08698391169309616,
0.003960408270359039,
0.0... | 0.093815 |
import { VersionBadge } from "/snippets/version-badge.mdx" This guide shows you how to secure your FastMCP server using \*\*Auth0 OAuth\*\*. While Auth0 does have support for Dynamic Client Registration, it is not enabled by default so this integration uses the [\*\*OIDC Proxy\*\*](/servers/auth/oidc-proxy) pattern to ... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/auth0.mdx | main | model-context-protocol-fastmcp | [
-0.09376100450754166,
0.04966512322425842,
0.021096086129546165,
-0.046366333961486816,
-0.004969877190887928,
-0.001051973202265799,
0.003307354636490345,
-0.0032296108547598124,
-0.027024006471037865,
-0.048126447945833206,
0.018671641126275063,
-0.03536688908934593,
0.11342547833919525,
... | -0.057224 |
protected tool result = await client.call\_tool("get\_token\_info") print(f"Auth0 audience: {result['audience']}") if \_\_name\_\_ == "\_\_main\_\_": asyncio.run(main()) ``` When you run the client for the first time: 1. Your browser will open to Auth0's authorization page 2. After you authorize the app, you'll be redi... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/auth0.mdx | main | model-context-protocol-fastmcp | [
-0.04930519312620163,
0.012690591625869274,
-0.08878897875547409,
0.024285640567541122,
-0.02640984207391739,
-0.09534844756126404,
-0.015425414778292179,
0.04835815727710724,
-0.023844461888074875,
-0.0425679050385952,
0.01436694711446762,
-0.04353103041648865,
0.05598831921815872,
-0.031... | 0.08512 |
import { VersionBadge } from "/snippets/version-badge.mdx" FastMCP can generate standard MCP JSON configuration files that work with any MCP-compatible client including Claude Desktop, VS Code, Cursor, and other applications that support the Model Context Protocol. ## MCP JSON Configuration Standard The MCP JSON config... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/mcp-json-configuration.mdx | main | model-context-protocol-fastmcp | [
-0.05931396782398224,
-0.0220728050917387,
0.03132294490933418,
-0.0501914918422699,
0.0024141997564584017,
-0.02332661673426628,
-0.06638530641794205,
0.010512051172554493,
-0.05715883523225784,
-0.0018796315416693687,
0.03145887702703476,
-0.006780501455068588,
0.06723258644342422,
0.000... | 0.016246 |
install mcp-json server.py --with pandas # Multiple packages fastmcp install mcp-json server.py --with pandas --with requests --with httpx # Editable local package fastmcp install mcp-json server.py --with-editable ./my-package # From requirements file fastmcp install mcp-json server.py --with-requirements requirements... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/mcp-json-configuration.mdx | main | model-context-protocol-fastmcp | [
-0.01713387295603752,
-0.016748346388339996,
0.0029002733062952757,
-0.08876082301139832,
0.0052491445094347,
-0.042183052748441696,
-0.08894822001457214,
0.01612974889576435,
-0.06301702558994293,
-0.010885286144912243,
0.07108675688505173,
-0.03557838127017021,
-0.032624952495098114,
0.0... | -0.10537 |
and provides a CLI entry point of the same name: ```json { "mcpServers": { "My Server": { "command": "uvx", "args": ["my-mcp-server"] } } } ``` If the package name differs from the CLI command (e.g., package `weather-mcp` with command `weather-server`): ```json { "mcpServers": { "Weather": { "command": "uvx", "args": [... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/mcp-json-configuration.mdx | main | model-context-protocol-fastmcp | [
-0.08128885179758072,
0.004030400887131691,
0.0535326823592186,
-0.03413006290793419,
-0.012134659104049206,
-0.08643508702516556,
-0.018485847860574722,
0.0032333291601389647,
-0.011958600953221321,
-0.055136583745479584,
0.04441014677286148,
-0.048519108444452286,
0.05725732073187828,
0.... | 0.015922 |
import { VersionBadge } from "/snippets/version-badge.mdx" Anthropic's [Messages API](https://docs.anthropic.com/en/api/messages) supports MCP servers as remote tool sources. This tutorial will show you how to create a FastMCP server and deploy it to a public URL, then how to call it from the Messages API. Currently, t... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/anthropic.mdx | main | model-context-protocol-fastmcp | [
-0.027585159987211227,
-0.01576322317123413,
-0.0024411261547356844,
-0.007037808652967215,
0.030695060268044472,
-0.04642842337489128,
-0.00715969642624259,
-0.00466183852404356,
-0.015022801235318184,
0.0203964002430439,
0.027218518778681755,
-0.01655544340610504,
0.06391260772943497,
-0... | 0.039032 |
server while still allowing Anthropic to access it. ### Server Authentication The simplest way to add authentication to the server is to use a bearer token scheme. For this example, we'll quickly generate our own tokens with FastMCP's `RSAKeyPair` utility, but this may not be appropriate for production use. For more de... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/anthropic.mdx | main | model-context-protocol-fastmcp | [
-0.0685967206954956,
0.0290133748203516,
-0.051158566027879715,
-0.021369175985455513,
-0.024320844560861588,
-0.0318513885140419,
0.013641154393553734,
0.03909284248948097,
0.03402222692966461,
-0.03211580589413643,
0.008296906016767025,
-0.009806535206735134,
0.03743989020586014,
-0.0395... | -0.012527 |
import { VersionBadge } from "/snippets/version-badge.mdx"; This guide shows you how to secure your FastMCP server using [\*\*PropelAuth\*\*](https://www.propelauth.com), a complete authentication and user management solution. This integration uses the [\*\*Remote OAuth\*\*](/servers/auth/remote-oauth) pattern, where P... | https://github.com/jlowin/fastmcp/blob/main/docs/integrations/propelauth.mdx | main | model-context-protocol-fastmcp | [
-0.05947745218873024,
0.04804890602827072,
0.0042753927409648895,
-0.058992862701416016,
0.011948834173381329,
0.0031542263459414244,
-0.03590657189488411,
-0.026285136118531227,
-0.023947423323988914,
-0.02781185507774353,
0.04796763136982918,
-0.034407082945108414,
0.0991687923669815,
-0... | -0.045196 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.