6Z502_;*SGTE77WZet_4M#&-riovz4rW%cD&aWFRnQ`qaOLpV?l)s>5l^t5)3={G-X7+e;
z2^4hI4zwpH4Q1ZIoixU5*yLIHd0_Sp$M;wYgM*b;WN3uta~P1Vwgm;TQ6Y(qDJmIy
zwYNW*KTkVdcPR8L1lB9l`&ght4r4Fdctz`CL9)KuY52@)1fD#Ur;^KEzhbpH-G5-S
zrgdp8SJ)ZW0Qw%DN6wrp%}0FXAekqhhjOUh2uggg#w!Ska!Ll=-wjM%ymo7Tm~_>v
zhMb9Y??T*MPkd|{tMhA?)tghFYSl67{(NiJTV7;KzuMX6$GG(zRUB!J4l7+1Zu)Vx
zYC|wI7~!d7-XY2oRg8VVcS0l=))38+8Wl0$)0Qq0?+#mA?ipaI2Q=c%W&52K&h!id
zPd^$O^|XD(?4+lsPgKikwVdpn)eD}~d*(3y`cpcS3`A86*|U&rR+g;`U&mhYI=&hT
zBbo2M;T+hPT0NwkD&JHqH-MJiwaE{J5T52`d{T648JuOAkQYYLb7;6?r!nbK_-%nX
zMyng)3L*mChA3N?xp=oy&F30v1x*mDsgv!EO-*<-Bj1FS50S5xCCxQ`q*R;ao-llU
z_2eu5^!^GhRSG?G>#)~XIUu3m{9^Mdm)?jCk|Z!=bpZ#1Q}476CA
zr$FOt7s@w2ZAS>2QPR@U)qn7-8$e|~AFM3MlwG#5ZGp%{LlhW=CS7LG`N)2~RNeHV
z=4`FN^EyU@y+Lj}(Tu#aBP2~>*|)yu+KSE*{=^z(@DpSE0pmiiWe%x%3q!fj8SE_U
zlZ_?EbH-#n+h!9HsRz`HyRAzKv4Yo_`!Oh&EbC`+=f;x5>C*e0lihr`Pycn5J|J$q
zID4t~7O$3rH~e|j8m4`%uqA3lk^BCFUe2hMKQh-}Y>+sC0SlY&*SPYI#S*c%`6dKd
zidfEpWEpm4u6u2x=#dpjMc&ul;LAKb)w@I!%T2TH7i>4Bf?P_hGiI_)#%7B^1jlV#
z`z@hKaC)MhU9uayy_e#CuwRj^un=pE+D|a4@;!rvO)FjvVfW{`mrLoof$d{wSrEDk
zs-K-GJ*%1FEI)?)yga2aE-gz>gPqHng!Y+A5*WKXPle<`K=Fmt1Pl#Xg{`jIb=hy=
zVwPKl=CqiMm%k~aPgRJ(kghu$jb;350|TwJCOJs!v7LlDY`|l-v*p9vwzEa>6u@|E
zCDqZf9pTlw4|g5?Vrw}5Id@&AKXVK|xe%5WWjN5&0{d*v9CgzmZ*@*hFU4T0)iTeZ
zTBzrO2=!~E*lp0(ME~x?`5|Pab32cry{Q=|b3c6}Ahzx{j&xb{fPatQ?#rVypTzxR
zG}pi-N6*BMpZ;L$d+K)72}-w%jKd=q%-nI+z7%2ij_pLODS8b(qJg}ZkC}B30`%-=
z#)}3AaSJEw0)wGCbJar*{1z$@`AkUF4~M6Ghe9ncU@(~8ABzSZ`A4KP9R$orW^F6h
z`=6>pR#d)p@lnEx(^;QDN=u!B!^7FXefy^LxPwZBglQbxI#}+qhG|<-wO5Rb7I4+{
zt_cMVAye&z5>05m3nuqigNQm#!P*!_B#x&?7Q#C&U{A0>3!B1kI|Ks%NW=c_abdm?
z$&FNff2RrBE*0UC)%PaY)<^->Rg3RGew@+R+7>kbYe%_lKTgQmr*GJO^nH1@rzstw
zqc{WVAW@|DyquPsudh*bq0iV-OlAu736R}&#wui)^iHNl#sZ$_unXcoeeB&3POT!W
zsxxv)I!C|QTBwLx%E-g?IC5K*uPa5q!2J8Hp6-XRu!f~Eb|VbV)mZqwk!=;OxhX{o
z_9X0sn##vKQjcwg3d4kS^B5MToVin$$6Bb0YEeIy(^5`JSU*b3)K)!EdNB9bp$_>P
z8K9B6o%>TDf8BW9*Ha*4A`SS!Bi|hW@H4%yj6Dil45Pwoo^dJqdqw>KgkMjIMNmFt
zgwWE4rWZ6gCsZpLyIKkV+A=gFy-@DJWa6v=1Bg=j?d47Z^J
z`$5=U(`?}Y+lkIJ`ZxQ5CUSEA<-4=eQx|#;xePo9>fq-+d5N64I%=eUZ50AxwX@CG
z3&myan+(J-rprogSW9z9RXRBw2v(?m#k
z?y*U(exRV^QtKY9;*y;(kss=--dZpb6r2cdWr&UyKR9|U*>(z)2(N{Nu**w5?x0RX
zKuP^Qbslcugu9#ixSPL^u?IX};QQ8wy*l&RG<)3q=DGI=x=h}pAs$4i
z57xM7hLj|Uc={rZu|>j>3$aXmOE)Kzql@Rz7cML)qF+Aq+BiqZrsiftL&Fm`Mfs+6
zX5=1D2~!m-Vj0|5Y_i}6_{)*5gXFMdBw6BZ%$L2|81(yb{d>6
z?HA`QF1!>wLoUJ78)LKN-C3FQWpF|gx!xEMts08zH9jLXyv0NGj6u8vdr?p&DF4ebh}-R
zalZ!rHR_N4Khcprye>z@E$ib@nr%d^LyKCVL?-;?J38K5ywU*I53g@m2M|`
z38xKM0|2sMT?31LtB>)h0zmuaRQw8DeYcaJ({x*?>jYPoPHSYtQ|622ksH?n1QCh^tj12=iYL6Ofgo
zc((7(3}r}$e8HIA)E8r6=tX6Zj~fq6p`X#whu8Zu7B|dvnPjFM;&Xma1zgyx9G++V
zx3JNmIyp!RRMI{cnG+u~O`jU0!s}perpaaUJ}m5t#`STu%mbrj+pEqxC+dKcR8rEs
zl02($o6c2N_*qF_`gOBs568;>I`%&+oA?vKR{~Do1aH9M-=K}}`mncVxJ?Kv9Rc(K
z#K@zHKXUx^`6=t8LF?;9d`+b}@KBkyMhTd`u(GPUE4>uZYHDICsWad$mz}7zL7C)t
zFMSlGP{-nH4CwLxNPq;iI^fBlBUma98LVU=D>v-D0_AcT2YoJ)vcA6zmh)(twd53`
zb07lc_Tyr2s=0voXSF2oFz)1zl1`PN{sapSWd|Jy%!7w
z%Ou6$d`0o{jIR!m7qQ8+03N}UL>s!T5>}sC!@#m~yD3EY0Ba9p04SpcgXLUl@EYYN
z6n|21Ar|8iHcBKZZ0u$8HSl`;9a#0d(*)Jfmtr^YHYSbH#lmxFl#l5iurVMvkqbUi
zbqG|U!Xslxq?up^@g4=K4WM2JSy56!
z(p|H$+Nbf$Z^tV|iZ^6)=AOJ;2S3=s1I%bN)XVaJLQpzr5dIi3Rsmve9v%?yDW_+c
zB_$+q3vgYpR|O~G@y54*V>`k<*j(UZ>^
zkn+p|ZMphowl!g3%%+#XAJQ-bYEV2h??F_?q^DnBOBH;8dpAI+(eZ0!>TG|lh8Fwu
zm2C?Gx`X?t=sbu1is!yebnVLfkSNZX8C_d7!9g^NENK$@R@e}F;&**uO(U_3&oG&t
zRjBCh?v{4an7bM!mBW~5#R(o$#eD-jW;D7q>S=N9{O^)X%G#bztl1>1a}vNx!9QUo
z21<{!bnUzjJlx$@C%S~eF(_@ym+}%yY_QCiDP?!(qFQz|8vRI5xi}YqqR)b^TGC)2
zk_8(a+UvhDllV740%?M$u|Np}E+rDK=I5-9G7zbhE06oca~NqK9{uCCbC~
z`JdiDPI!d>074$DK#%U}UmODZp2oUIXb%4Q66;5>1veu|H^4rTN;wd2>p#mPy$;mu
z!<9TRsU5V{!T9@e|3aTUK~eH}@tbMVDyW2u9idYHT#_-^fvBoC<5X49%kb4h2J-JG
zdraa#)b(ccFMvBc+Wp}}#$X4cCddw0@m1#4KVU_Z_z!K6?Od&b_S)I~;X`!bby`Qr
zH*QuzOKesN%Yr`_9)|zW8S<4oRnU(w?8M_K$Q>)rH`LctS(QoNJ+Hucb~KD|gQecR
zY?}({KNqK>rY2*V1-V5}J*hzktA1sk2GAs#`%C~$;(Q+y!^RLX^Iy;;Pm-Tjph}H;
zdxi`qUTlL7*2mD&`%{~S5DAp_1;^reH*~eMI8;@)i@gdhJ3XTacb%1*NH<$;btDN4
z@!U?$PD=}2&U-7N{dUgw3@GuR%mTgert$^%k$xsO^>G1$;T1|;|e3m?{n;nq_-DdA%1&}BycN){!pbKmfw
z@_KFV9UxUVR2T?v1Nu2s-Z6ib7|Hcb&;fU`E46KTPE|__^yV{#0hk0-+SF#ieJ&$Q
z;O-uUBCCNP#ex1cc;87j^m7YROO=mN^&f^QX(=a~t;B`_
z)Q2BxY&A7G**9lolx(b{r_dH#k#s*Mb-MSlbtRQ-V0QI%bhNfW`s_j2hqD8FS+v=8
z92$Ln#$8h@eY_?o$;p#sFgTm-?rZjPbrLN3VbO!yGo5J}rFGSkl#jq8?XQle7MX$p
zNIR8{^g4kjDwliK_;K;s0%I0$`~ZBl<0c53zRWCWAIy`wwiZpr{F%RadJb~K6vCT6
zv@}+ioSv=(j2ey1@H1j$!;VD>H{q7x&t4cbl6-3=n8qZ3on
zrYYc1|AK)Ro>_P;o73r$e9T<~tGW1<1iuui>|xi-a(iRiW-4EHhJA{S7GiZ;hk~=e
zj`Zbc=WcL5el~k+)y*70L{1wqYkAHak}29X?FLg@{@Hc9Wvk#;6D?OCN@0bE0Zh;M
z%vCK%jb=AjXVj$N@G`W7cZO=78Jb(bb-O?|(&f$S^l+C*idyU0xG=Wtiowek=nVlF
z){)_kY0ilKv`GJa^=ZEPb>{v22uO^Ga*GQtC93`wt;)g^%CS1R0xz2iy$#omq3xaS
zfmU#rqhgADjKNonsr_RoHktzFwRVlQ`4PEuAZBwv@c5xT=ALYg)h
z$+HJHM$~unX!Eq{7U#R$%N0he@E9RsS*LYk>Q=X(^A2nR6n1OA=UxGie$ivFI+%ety{#m~Tst)}p*4h-H9H7T)e$id
zD1cz~1L&EBE^>rHatHE)@!caeeYVDg;-U$LkS!lw<*NhjlO=-3B!?`kJW<}fi7Q`E
zvPWoq>Ph3^;1~yO(CIbeMXS>tO|cQ_CL@S{u)xR^e=nVi{DcJU06OMd6Ldu0<#noL
z-g%u$GsB6gdg?o%M%bLGE9}G5iynXrIL#(~NRO-Tk$fw9>P5x+7$pJjaAxnhmSbIq~8Q}dkA+#WmH!bC^R_Zu8=j@bA5mFGxu9xxC4=@YZU80OQ&C#WWDa-@S36)%;D*a%>s>1vne`S(hdWF*NVOVRqCCJ-@Pr{Gq
z>Dmd8njBeG(qm?nn6v^0+WC#t$6F&Qx=04`289^K*f_5z<`5hiRK|}mZVAtp6;_!hb5rn_}azrVpb!*O=L%b9&RNrb09
zs0*TYn!65i>bg0qwl(}G)0Ro#SF&`8NRSoqjZj>A?29R`7&ajewNU-VNYNgw!4O0}
zC&OfWHoQh4{9bzN5=r`Su5NS{uKiOrT4wZ|t~z}^3|~NxhEqos-ll|Q?YUeD2aC25
zK8-kZnJK{K5z3d`=787DOqEB5`%KolW?t^Ftu*K#@5gDVHz@dB*=&ejad?#@U*_lHOQrW1W&t3j{Zh(ZepIx
zmbsfw^!H4jUS@u`gi}l}0-iHo?d>@MeEjt;w9I^_H%RBCa0;G7<8C6_%)b{f#0CH!
zFW0=n-fRCI%&A;u;Inu&^lU9M)JCde^+tPwNusVzgB=f#D$7XavnZy!ISSro`#cXB
z!)4knV|WzoUu>;YlC9sm&Ly_l#dcH1dk
zla2O?zvwt!YO~L0*|#&a&bszARh{$A_n7^n>#}rvrZ2ykLE1Ook6zfMhjBx0k^w2$
z8!M`Z9#)NmgPHayi{8Zm4UFDu(;%V}9$UfeuU{
zcK^c4klje64moaHc|?vsGTW>Z-rAFtm6`tG+sQauov?cl9o017=jr2Kg-mxAb2D{z
zeEKZps-XCbc^!u2dMxWFTUdZN2E3t{3#)WJt{!#I99wqnTfF!kB
zO7ytTD&$4w!JcpPejUp};#Tr2gum;~{DJYh@KVjCJXhx~dSai>l!k_0!faZM93K--
zUI5nFuC1jhT)-BQE3TD+jMdQ6)VxSC-!JpzNm${4%WOnCyf(e?-8tbWt<2nm{kM-Q
zKYkoEgQ*lh;cTJfbFXa`{XJJ#Q#mIiTdl1g&11WkurLuKej-_dVQqR?xxbL(=1vx*
z<6~|{UF2=2^i>?X?p%+{>=YnD=ol}Z_VV`{GS5chLu)zFDU0X%UJx=GeBs)t(Jt3a
z)qMl0XKtggJ=IJOi*s3i+?QvRcr9&t)C;A8dcRZ;n(!rjk^bRYR(qbO)F3xkw_I#S
zTt`$yF>81{Gr*G2Pb+~t+xTxOe9-4VwQ*h;-uR7P&n%q56#ANCAwy9Ojj=43jdsjk
zogY9gL7lZue9F$&yaEF2qK(2LeZW_+VmMxZYkf^fZPh|En}2ASHVg0|_QwcMX*MY5
za~xOIOPxgP`EL+Pk8mV)ZLp={~{eaM!)$t2p4x()e?;V?=)tUYAb%{R0
zRq%-3;s^K5bQ7{U&9bsdMBy|H3||HhAz_V1JlO@Xru(XwN)r+WhkM-RPn9Jq(kRKIKW5f2G~
zJY0Dg3p$V-bYP#9r?^rI#A34L16UyVhP0iQNpsv;c#0kpHZOr$TSae=%PujX;&V$Y
zvt~Y0YT4S_CaVwW+1uM|a|w%w>eZ_i!F`fNtYRWP7#kDfyeU1Kni}svmyfzb3OYU8nkJenkZj+7#TNo;(Q4|Ztm_*ovu$)UV{kPSvw!9q{plNZT^<1L24M2
zfAQtZlOB%8k>1|(6T{9dH`O-ALjoJaI2rd4tFg|N>^dqGrWJZDsEIHk6$YQjDY5I>
zZfo!Lv<`u~rYC{Tf8*2${#Z|ClCqB8XN|1FB|TD}NY6m|Y87RL@cV$vsZ#p8IDF#3xQ;`XE`Q)7akj*&2;D!`Mu)!a1#e@bkh
z5L3OlK-HpO40?u^L$h6mqW7}hU1j;K_P;DhXEKz)P2%K7E0TBU|4MsK%
zY&^|=TW+g~RvGlio^1JlJA?^X-uv5DL;!>F6OsV-cMV>#+%AsdGl4)LA)@FHa|;^7#%acDx*3N++#p{@r~%7F@70
z=_(B(3RAs%AkU2O$Z+@&8Y&Hi#tP8g=w;?M{OE$S)hpT&-QQ#}+F9pZ=R4e6#rF5k
zSpJWlnb%i~+pcA_3Jtnc_d2%9oDy{cu&dwE8e6q9sR>*J!%g8!Z|C{+;o9h%gs!4v1Tj+!V){;zIkeN!8CVBMvO30fsBt+@pD
zLz^H5;3!Z-1@}IFn_7AF{E^cQ1=^+F3EBo%SE$u{eN5J0^I-A`M+7cy3=WEb-q&Hq
z^tK<=gI(
zH_iDUuy7X>@XNK&5@#x^={agVFO7UZAv5a?cD-ZlLa#sdjp~cbMH2s;bT^
z*uNcQC_WT7&C%pY-<;;KqR6*jvp<71^Zx4wxF%K1NQziVmX)1ftFxGMAv0Ruy~JdM=BW4;L3@_&Q+4-l4D
z;#J8C!XnD(u2&)0s3$-waMg>OiRjvmcypYw;pY*`6lYM;O|nG2w249N^ic3;AuL!|G))F4A?0t
z>d$P+1BjA>fq>ZV7mPv#Ov7>58%GEretUK55Ae@D5LtPBkthSGtJ1w~LQwW6ZgmrE
zfj&1ij=k5P>OGEdTmRWNDixq*SLF;(fDYW1ME>88`u<+GF4o0n`O@q?}YWeGsIKi5VEY3bT3D(p*{p!EJ?gCho&&#v&fPeKx_cXyk
z-mfQp!ha~?>_bMdruOMS2<8Q_aG#p-O6n?vGY|atU;gW~#Y};Se-bE#f(E|Gca*>W
z`}d_$;l~DED?+2Fv1PQ0!v9?eUg0so^bbui;8dzi1Ac$PuXSGlJK!Tbfw)kG5Q1p_
zK`y89OVTPedz3Tx*01)zFKP5X-X(=arGWcu3QYeXO;Df(L#CysGXK?q{IemWplKCD
zt2XVA2hb7#v*Ul;r+?;7Xl=|rhu)`|{y~_yfZNpZ^zM(==U2JbPdLi+&knrQ0&cJP
z>4hTpUJB~B#{czYtfQJ>NxT}S%wRCkHi7mJO9DD)Z$+nc8Z7Cf=^tdt052vUbkg*m
zLy8|v{~$}>@gGX0yASBPsNS3YL6!{gvh=OThTU^0%-@vIar`{&@AwZ*^*n`m4$-|a
z{dML9KhgkbiVqn^2{5RJy}I)UIr)zN5C`VID0tG#JBKZbHI0-E&61-_@MIcIVdEJR
z4?*6CF%UTyk-+X5e`2nPh`!(`HC7FcQjm%x5U*01`o}(pL`I%V%e)bi*U1CWNNUaE
z%g-MG2=4^&0C@24mwo+DPNN3gI;bU)$)DHJv7R%>Dj&77%woSlKU^uU*3iTuTVJX?
z4=5>8C%PLFvnGo``^f5N@Q1i5hu{~3#*REOcv)m})Wgq=-0H*>bF*ORqHWU$86&t6
zjKyl(q6;gx`%)`4^@trh*301K=Rp&FYpWey+UKhwV|A28M=FJ=DW(3z`7(OwJeZS3woeQ67?SFqUX12l!z7
z|BCbeevGWU+wmFb-@tUwcNPW;R3NCebXxK$S8ojBy7C?Jxp`!Z6B2hqDkr(B5CiN?
zPXYN2)hE-#R`D^tei5|$k@)$W=ksA%ePyr8E{KM`XEZi8itIdxg^m
zIOrA-!qR|Xnk>nr`)y=FQ}B_aIvph`{fu2a4s*kLE%mKb(l;gI`XURpl$ALpDHr_r
z$rA2d#E&(_h*M()dDQ`GPLP;7k{f>34`;I`Lf@i#M2cAbI%MUw3{6Q^lSZ
zcTa(~66zvCbX1I07g)8WU`m(s_$J0IBjCQD#;Wu$QY+hC3wZ^2w8`9wwGSCh%O}A7
z<_3a%KX*SU7SKE?RV{7dyyCRxYizNo#6G?k+4G
zQ1@(bf_-HP_WSf-vlP&3q|Dl>@9@=o%&@;e1~8=RRU~kQA4jvv7=j^&
zG_q9OY=YmF`e=^q_mTaYr3W6qU(4DIDPdM0`DLJ$GtvS!<0XSmn84~XK*7Jd*j9NV
z@gYTMAZ$KF2&L%`5&Yo#z3+fGd~*x3r?|c#iruyWP*li+WPl^9{KY^_aNI|UHS@(v
zst}RbtHmR*s8dXLSf}SPk76>_bEU&FMAJ&Z?9@&n5*j3spDOL-phi-Zf*bErG=0T}pL3M4*uSZ&PdN%?zYL=OZRgl&>a_ujrG-_jqu
zqJeU&AUg`Wvt_wZE-8k_h9Add!a2i3Glos)RpbzH`o(0Ax?wJR=EV)6YO=Q`s1Y#^
z4mD$EumHZ^l{;&CL^qaB%G;Gt$62XPd%W-*;))S!8gdwUE)ALHCPq1KVy?gBSV0bg
zuCdZ7QCt`xx4xErH9T&23bGp@#1F!CFylKnNZVO9;MM_E$QfAtSYTC0Wnv#W2D(r@ixip)$^V%suK>4M2I*%eybgBIA#xA!gN5w727ouA@hsvu%
zNVKReGjW`t{lon!2lwzoE9lL6cI`V#Zku}$KT5MTnU+=HKrBVv4}9GLCmssgvljk_
z=3#@*!Txi5-2F9S6_y)ucdVuNm&Z>o_XiikgevamfEZ+hf;x)=Kb6N#kTwCeFQFx6
z@2%Jn8u_qWeisl&2gU9EP-}^`X^-~^#;rB7UuP1wP3bL|$7Bb(><6?(=<_K~0hqM@
zS)ix^OPLwYBI3n&N18miinZQe>QbKbg02%b7qvOx^F5#PlNV=`TIOoT!N4b1=dFHB
zr5U2wnuYo9!CLmg`+1>rUuTNWVMW&K1Ct#VKxcyNo3nJ|{3+Z6?wez%@xH0>{yMJM
zyFJ83Pt-Gx*)mUSH9d28d$PaP-Nd~XytKTx;MUMTzp+(+;H*h^cQ3s!)qHVyJ0b%w
zfcqoQ+Uikst+pVR5}I3}1bpG1>gY!vNAX$u7EAnuf{X&(v4To?|FJ
zfSY+l?jgln&Yfoq*WuG4?=S4~9sjPkA5PBL_HnJ!72ZUTa`e4M|5!=$dK)T75%yVe
zy?n(dqdzNOmW8=ze_Yi43N5XwaqUzwYK@|yB`q#_r`fixiH=uXt!=Pk#%BvK%VZl9
z?~J3|Rzz)>6rIPKy}BeB*mUglzAoi?!HfK@sQb{5qB5W@Dzf~=e2}OJ>)!VI
zZG%NMoQqgXr3f3d5M87D!8Wo}u4R-HlC1(U-AT7b>qT;Wi}%|52H9;Tu6{5(VYV@J
zfXZ`jJIc%BT;Q@N3gt1dee@_o+r1itT_OctPxDqjrU)?Ws~nR1pSb0h^ZVj2cBcv_
zetN$?`e{ql-1tQJoQYzYz?AnGMj*Ub@IJZSjEQG;R4j`~r|Y
z-VxG{eIR?5k825=td4jn8c&F4A31V%0Z%JTa*+(i7|u<)7VXh*WSkPEk*lW$(Uws@
z$W%Ex+nIkfofeCq^OD>U?M~X+6W#V8(}}^Xv^ejJ_ZLHM=X)G1*NjB2J})2JHqQkfjBO{isz%dw2{ROFwWvOO@iw-`q1!Z*eLJbEvhoqMNdcM>qf$!$0S~*VLA5
zjtRIj?P}0L?j-G90`Gz5B$w**tH+g>GtDGQOYE-mkMPLhHou-8|5A0yI0kRFdpG1H
zcJNFRi9CnW1;A`4pR+T%Cwki+YER~^c)v?5oL{wq$`bprPRyc)#g?#r51m$y|nB5L5@rH#}sh6>h)T*XI6w
zy?9OEVQ>5Ngzv^dVBBLjH^g1!D5|A$Kx9Klz-9BJ28$@p#cBE;ZGW8Wg~(xz$B(Zu
z^3Q)@KPXcyvK)EVuc4<2XgZtFxUImp#*eqElf-w3P}W(u0Bspr&@#E_&~g8(2tcz!
z9rEe0h=<}u{B)&zwxNkpLz;5xM0k3$$H2r%z0K&=g#ipM7U-?g4+stAr>Fu2z2vg8hXHi7
z4S>q+^>a)QxNvh$^yZpnOneo%6)i<_gKN2O01*UCKPX}cdMLcIfjCzO{kk!Ds2}nJGGkC=XPRx17
z#45=4IK>$~otRy~o13er-m{qrM)Pgz=8GfxD!`25`}x@kqt?h0q{BkcRJTlve5}PL
z$JWNkhO4q4Z>PQ*W(YmipQ4+$jzR4uE+zB!?RU5E*E?1FM$sqk&0^Mgh`rXuYzE
zK0yYf2-^DkZs@q*XZ!($hEyFsAaDEujaGS$=NI>&;%A#9p7NS+U}h)OFEI}wbo?dDztG?Hyw--LWW5eaTvl<5YwbL1p
zb=^$^>k;Chwt$}^k7#sAa=OC)F4*2Tn>Y7F@r8$7Wsbq#rJ&li>ofCn}gVY!tmxV)BB$c1VA_P
zIT^mF6%M`NSYh}_9_Blain>k{ynW7mi?RwEjj7Pe4&scms^JQjro=#DX#YC4LuYM|
zKYxF6yLcQxxO{Ulg0K%l3%kK-p&1Sm=diKPIQ`N!o;bc|ECO(q{oPHP*>9%F*PC1T
zKG`h{SICa;E<)zS2g}Q~w_1xU4UFmMlujLN_=@)Nypi;0y09{-VzhOehC`%6pcRdR_3j$)b{IAfamVHz#Wy&lMuu9H=W
zAIo85w+6wt=KdG=9v
z3-#}Xa8n4L+HVX;vEoOGGi5hAKFxi7;Ae!xa;UbTEi`gx?KO%lycwXa(Hs*AWc1QG
z;i(!BTdks}$spTlEF)fV>U$?+G)VGH_4P-q1&n)z`&wjS-YRx;{b(UKyjv>b*0ad7
zbVbDrY4Q(R;XO;JSa^T)c45Cl^iAE#)(B2``3}qOo5BIKiM_q6DK*}dKQP{#60MM|eRuu}i)(=bu6(Y}
zIF5@tcY14k4z;&35)N8uG{wDlpObW*IE_73s&Mff_cQ*7vp*pTLYrm!m=$!$dtop|x-;R<+0{6dbN
z&WQdqXO;EdR0Wnam3+IvbR|j;Gtv`tbH?u6Cy-EFwcJ1e^GUgz<@lH`1ex>=!7O<8
z>VcquYd;E?i&Ous`;|{$%&M>WfJVUjhn?TE2gsvU(1Hizj1c@7u9=Pd4<+67%7Sk8NBfQAYlIZA8d}`hXzaGOADvLXZ~MG3rE3Q
zMP$LBZAmx`RPafv=Rjf{%UD71R4`%XjqmE%x%rF*8=DBdDTk&-$YT9dru*i+h6Dv1
zM-!7O#X*h>n(qDonf4)6je@K1V;^Tc6%CUhoemd8t2jS{&q9ZGfVKBgd7|o<-9z7H
zTUb~ntQ%-(WGn?pu$TnO`O~ca&*lT?nfiefHEtVtFo%P6fx9v6K2}V6^!Jl)T=pu{
z4?iz0*>+9%^6jkq3s*mRD(ba%z27RW)k#(BwwYD9wS~7ndl?i}6$M=SJnPDKphw|b
z1TcbKjP=r$642#Tj{s@M_*?mpVJ|W=NFh}Ut
zFtn`=4hN<(7?;NuwqCWEXIv^Bzo7V8-s9w)-NG5V#-(d_E8W9D2=;!vxc^~+N-n8Yr
zW3IdaJ1PUXt7LoS{0;p;MZWItI7|YrciGOmpnxAZcB<`ek3*3sP?73FgZ}jN=N?fr
zYF}cGYC~d*MR-LpyO!3eX4$-{zc07-&sg+c`yuc~u0!&S;#g-r9K3+@8OJ_s1g?C^*+D=Qn=
zPtp1)E_77eV^+fT)lPSPM6oO}0IO$Ux+tpzw@xug%
z#;#LdD_4J3{lJw}{AvlX_othdlCom@ilxV&vr%td4%jW|bc}wjnw&t^BiS
zi^KQZTEInE539cA0lPmHd*ia+vsF!cgHghQ>{!st`C=3I)~#ECqrjKd(q3B0=db20
zn=1}1_WRxce_U~3`#;g_JsD>;k62;#+Dg?0&M|whtSsW*Rk!YZc(&8sUwd=kXRqcd
zyL~VDQ6EN?1F0MvK?h*5abLq$5&^{;!+-~i+}4s47RNDj&tU>8u_HF%%6(fvx8;R>
zoUsGribkl73qYCuU=zj`V3>3$(EM#($B($8FQ$SeZeCzf$Sbx6d$M9+S__
+This guide focuses specifically on installing local FastMCP server files directly into Cursor using STDIO transport. For deploying remote servers using SSE or HTTP transports, see the [Cursor MCP documentation](https://docs.cursor.com/context/mcp).
+
+
+## Requirements
+
+This integration uses STDIO transport to run your FastMCP server locally. For remote deployments, you can run your FastMCP server with HTTP or SSE transport and configure it directly in Cursor's settings.
+
+## Create a Server
+
+The examples in this guide will use the following simple dice-rolling server, saved as `server.py`.
+
+```python server.py
+import random
+from fastmcp import FastMCP
+
+mcp = FastMCP(name="Dice Roller")
+
+@mcp.tool
+def roll_dice(n_dice: int) -> list[int]:
+ """Roll `n_dice` 6-sided dice and return the results."""
+ return [random.randint(1, 6) for _ in range(n_dice)]
+
+if __name__ == "__main__":
+ mcp.run()
+```
+
+## Install the Server
+
+### FastMCP CLI
+
+
+The easiest way to install a FastMCP server in Cursor is using the `fastmcp install cursor` command. This automatically handles the configuration, dependency management, and opens Cursor with a deeplink to install the server.
+
+```bash
+fastmcp install cursor server.py
+```
+
+The install command supports the same `file.py:object` notation as the `run` command. If no object is specified, it will automatically look for a FastMCP server object named `mcp`, `server`, or `app` in your file:
+
+```bash
+# These are equivalent if your server object is named 'mcp'
+fastmcp install cursor server.py
+fastmcp install cursor server.py:mcp
+
+# Use explicit object name if your server has a different name
+fastmcp install cursor server.py:my_custom_server
+```
+
+After running the command, Cursor will open automatically and prompt you to install the server. The command will be `uv`, which is expected as this is a Python STDIO server. Click "Install" to confirm:
+
+
+
+#### Dependencies
+
+If your server has dependencies, include them with the `--with` flag:
+
+```bash
+fastmcp install cursor server.py --with pandas --with requests
+```
+
+Alternatively, you can specify dependencies directly in your server code:
+
+```python server.py
+from fastmcp import FastMCP
+
+mcp = FastMCP(
+ name="Dice Roller",
+ dependencies=["pandas", "requests"]
+)
+```
+
+#### 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 environment variables (like API keys), you must include them:
+
+```bash
+fastmcp install cursor server.py --name "Weather Server" \
+ --env-var API_KEY=your-api-key \
+ --env-var DEBUG=true
+```
+
+Or load them from a `.env` file:
+
+```bash
+fastmcp install cursor server.py --name "Weather Server" --env-file .env
+```
+
+
+**`uv` must be installed and available in your system PATH**. Cursor runs in its own isolated environment and needs `uv` to manage dependencies.
+
+
+### Manual Configuration
+
+For more control over the configuration, you can manually edit Cursor's configuration file. The configuration file is located at:
+- **All platforms**: `~/.cursor/mcp.json`
+
+The configuration file is a JSON object with a `mcpServers` key, which contains the configuration for each MCP server.
+
+```json
+{
+ "mcpServers": {
+ "dice-roller": {
+ "command": "python",
+ "args": ["path/to/your/server.py"]
+ }
+ }
+}
+```
+
+After updating the configuration file, your server should be available in Cursor.
+
+#### Dependencies
+
+If your server has dependencies, you can use `uv` or another package manager to set up the environment.
+
+```json
+{
+ "mcpServers": {
+ "dice-roller": {
+ "command": "uv",
+ "args": [
+ "run",
+ "--with", "pandas",
+ "--with", "requests",
+ "python",
+ "path/to/your/server.py"
+ ]
+ }
+ }
+}
+```
+
+
+**`uv` must be installed and available in your system PATH**. Cursor runs in its own isolated environment and needs `uv` to manage dependencies.
+
+
+#### Environment Variables
+
+You can also specify environment variables in the configuration:
+
+```json
+{
+ "mcpServers": {
+ "weather-server": {
+ "command": "python",
+ "args": ["path/to/weather_server.py"],
+ "env": {
+ "API_KEY": "your-api-key",
+ "DEBUG": "true"
+ }
+ }
+ }
+}
+```
+
+
+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.
+
+
+## Using the Server
+
+Once your server is installed, you can start using your FastMCP server with Cursor's AI assistant.
+
+Try asking Cursor something like:
+
+> "Roll some dice for me"
+
+Cursor will automatically detect your `roll_dice` tool and use it to fulfill your request, returning something like:
+
+> 🎲 Here are your dice rolls: 4, 6, 4
+>
+> You rolled 3 dice with a total of 14! 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.
\ No newline at end of file
diff --git a/docs/integrations/eunomia-authorization.mdx b/docs/integrations/eunomia-authorization.mdx
index e1d5dd481..c3d3ce12b 100644
--- a/docs/integrations/eunomia-authorization.mdx
+++ b/docs/integrations/eunomia-authorization.mdx
@@ -1,6 +1,6 @@
---
title: Eunomia Authorization + FastMCP
-sidebarTitle: Eunomia Authorization
+sidebarTitle: Eunomia Auth
description: Add policy-based authorization to your FastMCP servers
icon: layer-group
tag: NEW
diff --git a/docs/integrations/gemini.mdx b/docs/integrations/gemini.mdx
index 359ef4e0a..17e1c0eec 100644
--- a/docs/integrations/gemini.mdx
+++ b/docs/integrations/gemini.mdx
@@ -3,7 +3,6 @@ title: Gemini SDK + FastMCP
sidebarTitle: Gemini SDK
description: Call FastMCP servers from the Google Gemini SDK
icon: message-smile
-tag: NEW
---
import { VersionBadge } from "/snippets/version-badge.mdx"
diff --git a/docs/patterns/cli.mdx b/docs/patterns/cli.mdx
index 663399a0f..61de153ff 100644
--- a/docs/patterns/cli.mdx
+++ b/docs/patterns/cli.mdx
@@ -20,7 +20,7 @@ fastmcp --help
| ------- | ------- | --------------------- |
| `run` | Run a FastMCP server directly | Uses your current environment; you are responsible for ensuring all dependencies are available |
| `dev` | Run a server with the MCP Inspector for testing | Creates an isolated environment; dependencies must be explicitly specified with `--with` and/or `--with-editable` |
-| `install` | Install a server in the Claude desktop app | Creates an isolated environment; dependencies must be explicitly specified with `--with` and/or `--with-editable` |
+| `install` | Install a server in MCP client applications | Creates an isolated environment; dependencies must be explicitly specified with `--with` and/or `--with-editable` |
| `inspect` | Generate a JSON report about a FastMCP server | Uses your current environment; you are responsible for ensuring all dependencies are available |
| `version` | Display version information | N/A |
@@ -144,22 +144,26 @@ fastmcp dev server.py -e . --with pandas --with matplotlib
```
### `install`
+
-Install a MCP server in the Claude desktop app.
+Install a MCP server in MCP client applications. FastMCP currently supports the following clients:
+
+- **Claude Desktop** - Installs via direct configuration file modification
+- **Cursor** - Installs via deeplink that opens Cursor for user confirmation
```bash
-fastmcp install server.py
+fastmcp install claude-desktop server.py
+fastmcp install cursor server.py
```
-Note that for security reasons, Claude runs every MCP server in a completely isolated environment. Therefore, all dependencies must be explicitly specified using the `--with` and/or `--with-editable` options (following `uv` conventions) or by attaching them to your server in code via the `dependencies` parameter.
+Note that for security reasons, MCP clients run every server in a completely isolated environment. Therefore, all dependencies must be explicitly specified using the `--with` and/or `--with-editable` options (following `uv` conventions) or by attaching them to your server in code via the `dependencies` parameter.
-- **`uv` must be installed and available in your system PATH**. Claude Desktop runs in its own isolated environment and needs `uv` to manage dependencies.
-- **On macOS, it is recommended to install `uv` globally with Homebrew** so that Claude Desktop will detect it: `brew install uv`. Installing `uv` with other methods may not make it accessible to Claude Desktop.
+**`uv` must be installed and available in your system PATH**. Both Claude Desktop and Cursor run in isolated environments and need `uv` to manage dependencies. On macOS, install `uv` globally with Homebrew for Claude Desktop compatibility: `brew install uv`.
-The `install` command currently only sets up servers for STDIO transport. When installed in the Claude desktop app, your server will be run using STDIO regardless of any transport configuration in your code.
+The `install` command currently only sets up servers for STDIO transport. When installed in MCP client applications, your server will be run using STDIO regardless of any transport configuration in your code.
#### Server Specification
@@ -169,17 +173,33 @@ The `install` command supports the same `file.py:object` notation as the `run` c
1. `server.py` - imports the module and looks for a FastMCP object named `mcp`, `server`, or `app`. Errors if no such object is found.
2. `server.py:custom_name` - imports and uses the specified server object
+#### Options
+
+| Option | Flag | Description |
+| ------ | ---- | ----------- |
+| Server Name | `--name`, `-n` | Custom name for the server (defaults to server's name attribute or file name) |
+| Editable Package | `--with-editable`, `-e` | Directory containing pyproject.toml to install in editable mode |
+| Additional Packages | `--with` | Additional packages to install (can be used multiple times) |
+| Environment Variables | `--env-var`, `-v` | Environment variables in KEY=VALUE format (can be used multiple times) |
+| Environment File | `--env-file`, `-f` | Load environment variables from a .env file |
+
**Examples**
```bash
# Auto-detects server object (looks for 'mcp', 'server', or 'app')
-fastmcp install server.py
+fastmcp install claude-desktop server.py
# Uses specific server object
-fastmcp install server.py:my_server
+fastmcp install claude-desktop server.py:my_server
# With custom name and dependencies
-fastmcp install server.py:my_server -n "My Analysis Server" --with pandas
+fastmcp install claude-desktop server.py:my_server -n "My Analysis Server" --with pandas
+
+# Install in Cursor with environment variables
+fastmcp install cursor server.py --env-var API_KEY=secret --env-var DEBUG=true
+
+# Install with environment file
+fastmcp install cursor server.py --env-file .env
```
### `inspect`
diff --git a/src/fastmcp/cli/cli.py b/src/fastmcp/cli/cli.py
index 0c0ef8421..5715cf57f 100644
--- a/src/fastmcp/cli/cli.py
+++ b/src/fastmcp/cli/cli.py
@@ -10,7 +10,6 @@ import sys
from pathlib import Path
from typing import Annotated
-import dotenv
import typer
from pydantic import TypeAdapter
from rich.console import Console
@@ -18,8 +17,8 @@ from rich.table import Table
from typer import Context, Exit
import fastmcp
-from fastmcp.cli import claude
from fastmcp.cli import run as run_module
+from fastmcp.cli.install.install import install
from fastmcp.server.server import FastMCP
from fastmcp.utilities.inspect import FastMCPInfo, inspect_fastmcp
from fastmcp.utilities.logging import get_logger
@@ -324,135 +323,8 @@ def run(
sys.exit(1)
-@app.command()
-def install(
- server_spec: str = typer.Argument(
- ...,
- help="Python file to run, optionally with :object suffix",
- ),
- server_name: Annotated[
- str | None,
- typer.Option(
- "--name",
- "-n",
- help="Custom name for the server (defaults to server's name attribute or"
- " file name)",
- ),
- ] = None,
- with_editable: Annotated[
- Path | None,
- typer.Option(
- "--with-editable",
- "-e",
- help="Directory containing pyproject.toml to install in editable mode",
- exists=True,
- file_okay=False,
- resolve_path=True,
- ),
- ] = None,
- with_packages: Annotated[
- list[str],
- typer.Option(
- "--with",
- help="Additional packages to install",
- ),
- ] = [],
- env_vars: Annotated[
- list[str],
- typer.Option(
- "--env-var",
- "-v",
- help="Environment variables in KEY=VALUE format",
- ),
- ] = [],
- env_file: Annotated[
- Path | None,
- typer.Option(
- "--env-file",
- "-f",
- help="Load environment variables from a .env file",
- exists=True,
- file_okay=True,
- dir_okay=False,
- resolve_path=True,
- ),
- ] = None,
-) -> None:
- """Install a MCP server in the Claude desktop app.
-
- Environment variables are preserved once added and only updated if new values
- are explicitly provided.
- """
- file, server_object = run_module.parse_file_path(server_spec)
-
- logger.debug(
- "Installing server",
- extra={
- "file": str(file),
- "server_name": server_name,
- "server_object": server_object,
- "with_editable": str(with_editable) if with_editable else None,
- "with_packages": with_packages,
- },
- )
-
- if not claude.get_claude_config_path():
- logger.error("Claude app not found")
- sys.exit(1)
-
- # Try to import server to get its name, but fall back to file name if dependencies
- # missing
- name = server_name
- server = None
- if not name:
- try:
- server = run_module.import_server(file, server_object)
- name = server.name
- except (ImportError, ModuleNotFoundError) as e:
- logger.debug(
- "Could not import server (likely missing dependencies), using file"
- " name",
- extra={"error": str(e)},
- )
- name = file.stem
-
- # Get server dependencies if available
- server_dependencies = getattr(server, "dependencies", []) if server else []
- if server_dependencies:
- with_packages = list(set(with_packages + server_dependencies))
-
- # Process environment variables if provided
- env_dict: dict[str, str] | None = None
- if env_file or env_vars:
- env_dict = {}
- # Load from .env file if specified
- if env_file:
- try:
- env_dict |= {
- k: v
- for k, v in dotenv.dotenv_values(env_file).items()
- if v is not None
- }
- except Exception as e:
- logger.error(f"Failed to load .env file: {e}")
- sys.exit(1)
-
- # Add command line environment variables
- for env_var in env_vars:
- key, value = _parse_env_var(env_var)
- env_dict[key] = value
-
- if claude.update_claude_config(
- server_spec,
- name,
- with_editable=with_editable,
- with_packages=with_packages,
- env_vars=env_dict,
- ):
- logger.info(f"Successfully installed {name} in Claude app")
- else:
- logger.error(f"Failed to install {name} in Claude app")
- sys.exit(1)
+# Add install command directly
+app.command()(install)
@app.command()
diff --git a/src/fastmcp/cli/install/__init__.py b/src/fastmcp/cli/install/__init__.py
new file mode 100644
index 000000000..aa09f0165
--- /dev/null
+++ b/src/fastmcp/cli/install/__init__.py
@@ -0,0 +1,5 @@
+"""Install module for FastMCP CLI."""
+
+from .install import install
+
+__all__ = ["install"]
diff --git a/src/fastmcp/cli/install/claude_desktop.py b/src/fastmcp/cli/install/claude_desktop.py
new file mode 100644
index 000000000..cf97b6f47
--- /dev/null
+++ b/src/fastmcp/cli/install/claude_desktop.py
@@ -0,0 +1,121 @@
+"""Claude Desktop integration for FastMCP install."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from rich import print
+
+from fastmcp.mcp_config import StdioMCPServer, update_config_file
+from fastmcp.utilities.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_claude_config_path() -> Path | None:
+ """Get the Claude config directory based on platform."""
+ if sys.platform == "win32":
+ path = Path(Path.home(), "AppData", "Roaming", "Claude")
+ elif sys.platform == "darwin":
+ path = Path(Path.home(), "Library", "Application Support", "Claude")
+ elif sys.platform.startswith("linux"):
+ path = Path(
+ os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"), "Claude"
+ )
+ else:
+ return None
+
+ if path.exists():
+ return path
+ return None
+
+
+def install_claude_desktop(
+ server_spec: str,
+ name: str,
+ *,
+ with_editable: Path | None = None,
+ with_packages: list[str] | None = None,
+ env_vars: dict[str, str] | None = None,
+) -> bool:
+ """Install FastMCP server in Claude Desktop.
+
+ Args:
+ server_spec: Path to the server file, optionally with :object suffix
+ name: Name for the server in Claude's config
+ with_editable: Optional directory to install in editable mode
+ with_packages: Optional list of additional packages to install
+ env_vars: Optional dictionary of environment variables
+
+ Returns:
+ True if installation was successful, False otherwise
+ """
+ config_dir = get_claude_config_path()
+ if not config_dir:
+ print(
+ "[red]❌ Claude Desktop config directory not found.[/red]\n"
+ "[blue]Please ensure Claude Desktop is installed and has been run at least once to initialize its config.[/blue]"
+ )
+ return False
+
+ config_file = config_dir / "claude_desktop_config.json"
+
+ # Build uv run command
+ args = ["run"]
+
+ # Collect all packages in a set to deduplicate
+ packages = {"fastmcp"}
+ if with_packages:
+ packages.update(pkg for pkg in with_packages if pkg)
+
+ # Add all packages with --with
+ for pkg in sorted(packages):
+ args.extend(["--with", pkg])
+
+ if with_editable:
+ args.extend(["--with-editable", str(with_editable)])
+
+ # Convert file path to absolute before adding to command
+ # Split off any :object suffix first
+ if ":" in server_spec:
+ file_path, server_object = server_spec.rsplit(":", 1)
+ server_spec = f"{Path(file_path).resolve()}:{server_object}"
+ else:
+ server_spec = str(Path(server_spec).resolve())
+
+ # Add fastmcp run command
+ args.extend(["fastmcp", "run", server_spec])
+
+ # Create server configuration
+ server_config = StdioMCPServer(
+ command="uv",
+ args=args,
+ env=env_vars or {},
+ )
+
+ try:
+ # Handle environment variable merging manually since we need to preserve existing config
+ if config_file.exists():
+ import json
+
+ content = config_file.read_text().strip()
+ if content:
+ config = json.loads(content)
+ if "mcpServers" in config and name in config["mcpServers"]:
+ existing_env = config["mcpServers"][name].get("env", {})
+ if env_vars:
+ # New vars take precedence over existing ones
+ merged_env = {**existing_env, **env_vars}
+ else:
+ merged_env = existing_env
+ server_config.env = merged_env
+
+ update_config_file(config_file, name, server_config)
+ return True
+ except Exception as e:
+ print(
+ f"[red]Failed to install '[bold]{name}[/bold]' in Claude Desktop: {e}[/red]"
+ )
+ return False
diff --git a/src/fastmcp/cli/install/cursor.py b/src/fastmcp/cli/install/cursor.py
new file mode 100644
index 000000000..b8f5b3daa
--- /dev/null
+++ b/src/fastmcp/cli/install/cursor.py
@@ -0,0 +1,135 @@
+"""Cursor integration for FastMCP install."""
+
+from __future__ import annotations
+
+import base64
+import subprocess
+import sys
+from pathlib import Path
+
+from rich import print
+
+from fastmcp.mcp_config import StdioMCPServer
+from fastmcp.utilities.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def generate_cursor_deeplink(
+ server_name: str,
+ server_config: StdioMCPServer,
+) -> str:
+ """Generate a Cursor deeplink for installing the MCP server.
+
+ Args:
+ server_name: Name of the server
+ server_config: Server configuration
+
+ Returns:
+ Deeplink URL that can be clicked to install the server
+ """
+ # Create the configuration structure expected by Cursor
+
+ # Base64 encode the configuration (URL-safe for query parameter)
+ config_json = server_config.model_dump_json(exclude_none=True)
+ config_b64 = base64.urlsafe_b64encode(config_json.encode()).decode()
+
+ # Generate the deeplink URL
+ deeplink = f"cursor://anysphere.cursor-deeplink/mcp/install?name={server_name}&config={config_b64}"
+
+ return deeplink
+
+
+def open_deeplink(deeplink: str) -> bool:
+ """Attempt to open a deeplink URL using the system's default handler.
+
+ Args:
+ deeplink: The deeplink URL to open
+
+ Returns:
+ True if the command succeeded, False otherwise
+ """
+ try:
+ if sys.platform == "darwin": # macOS
+ subprocess.run(["open", deeplink], check=True, capture_output=True)
+ elif sys.platform == "win32": # Windows
+ subprocess.run(
+ ["start", deeplink], shell=True, check=True, capture_output=True
+ )
+ else: # Linux and others
+ subprocess.run(["xdg-open", deeplink], check=True, capture_output=True)
+ return True
+ except (subprocess.CalledProcessError, FileNotFoundError):
+ return False
+
+
+def install_cursor(
+ server_spec: str,
+ name: str,
+ *,
+ with_editable: Path | None = None,
+ with_packages: list[str] | None = None,
+ env_vars: dict[str, str] | None = None,
+) -> bool:
+ """Install FastMCP server in Cursor.
+
+ Args:
+ server_spec: Path to the server file, optionally with :object suffix
+ name: Name for the server in Cursor's config
+ with_editable: Optional directory to install in editable mode
+ with_packages: Optional list of additional packages to install
+ env_vars: Optional dictionary of environment variables
+
+ Returns:
+ True if installation was successful, False otherwise
+ """
+ # Build uv run command
+ args = ["run"]
+
+ # Collect all packages in a set to deduplicate
+ packages = {"fastmcp"}
+ if with_packages:
+ packages.update(pkg for pkg in with_packages if pkg)
+
+ # Add all packages with --with
+ for pkg in sorted(packages):
+ args.extend(["--with", pkg])
+
+ if with_editable:
+ args.extend(["--with-editable", str(with_editable)])
+
+ # Convert file path to absolute before adding to command
+ # Split off any :object suffix first
+ if ":" in server_spec:
+ file_path, server_object = server_spec.rsplit(":", 1)
+ server_spec = f"{Path(file_path).resolve()}:{server_object}"
+ else:
+ server_spec = str(Path(server_spec).resolve())
+
+ # Add fastmcp run command
+ args.extend(["fastmcp", "run", server_spec])
+
+ # Create server configuration
+ server_config = StdioMCPServer(
+ command="uv",
+ args=args,
+ env=env_vars or {},
+ )
+
+ # Generate and open deeplink
+ try:
+ deeplink = generate_cursor_deeplink(name, server_config)
+
+ if open_deeplink(deeplink):
+ print(
+ f"[green]Opening Cursor to install '[bold]{name}[/bold]' - please confirm in Cursor to complete installation[/green]"
+ )
+ return True
+ else:
+ print("[yellow]Could not open Cursor automatically.[/yellow]")
+ print(f"[blue]Please open this link to install:[/blue] {deeplink}")
+ return True
+
+ except Exception as e:
+ print(f"[red]Failed to generate Cursor deeplink: {e}[/red]")
+ return False
diff --git a/src/fastmcp/cli/install/install.py b/src/fastmcp/cli/install/install.py
new file mode 100644
index 000000000..8c464ee90
--- /dev/null
+++ b/src/fastmcp/cli/install/install.py
@@ -0,0 +1,185 @@
+"""Main install logic for FastMCP CLI."""
+
+from __future__ import annotations
+
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from dotenv import dotenv_values
+from rich import print
+
+from fastmcp.cli.run import import_server, parse_file_path
+from fastmcp.utilities.logging import get_logger
+
+from .claude_desktop import install_claude_desktop
+from .cursor import install_cursor
+
+logger = get_logger(__name__)
+
+
+class Client(str, Enum):
+ """Supported MCP clients."""
+
+ CLAUDE_DESKTOP = "claude-desktop"
+ CURSOR = "cursor"
+
+
+def install(
+ client: Annotated[
+ Client,
+ typer.Argument(help="MCP client to install the server into"),
+ ],
+ server_spec: Annotated[
+ str, typer.Argument(help="Python file to run, optionally with :object suffix")
+ ],
+ server_name: Annotated[
+ str | None,
+ typer.Option(
+ "--name",
+ "-n",
+ help="Custom name for the server (defaults to server's name attribute or file name)",
+ ),
+ ] = None,
+ with_editable: Annotated[
+ Path | None,
+ typer.Option(
+ "--with-editable",
+ "-e",
+ help="Directory containing pyproject.toml to install in editable mode. Use this to include local packages that are not available on PyPI.",
+ exists=True,
+ file_okay=False,
+ resolve_path=True,
+ ),
+ ] = None,
+ with_packages: Annotated[
+ list[str],
+ typer.Option(
+ "--with",
+ help="Additional packages to install, in PEP 508 format (e.g. 'httpx>=0.25.2')",
+ ),
+ ] = [],
+ env_vars: Annotated[
+ list[str],
+ typer.Option(
+ "--env-var",
+ "-v",
+ help="Environment variables in KEY=VALUE format",
+ ),
+ ] = [],
+ env_file: Annotated[
+ Path | None,
+ typer.Option(
+ "--env-file",
+ "-f",
+ help="Load environment variables from a .env file",
+ exists=True,
+ file_okay=True,
+ dir_okay=False,
+ resolve_path=True,
+ ),
+ ] = None,
+) -> None:
+ """Install a MCP server in the specified target application.
+
+ Environment variables are preserved once added and only updated if new values
+ are explicitly provided.
+ """
+
+ # Parse server spec
+ file, server_object = parse_file_path(server_spec)
+
+ logger.debug(
+ "Installing server",
+ extra={
+ "client": client,
+ "file": str(file),
+ "server_name": server_name,
+ "server_object": server_object,
+ "with_editable": str(with_editable) if with_editable else None,
+ "with_packages": with_packages,
+ },
+ )
+
+ # Try to import server to get its name and dependencies
+ name = server_name
+ server = None
+ if not name:
+ try:
+ server = import_server(file, server_object)
+ name = server.name
+ except (ImportError, ModuleNotFoundError) as e:
+ logger.debug(
+ "Could not import server (likely missing dependencies), using file name",
+ extra={"error": str(e)},
+ )
+ name = file.stem
+
+ # Get server dependencies if available
+ server_dependencies = getattr(server, "dependencies", []) if server else []
+ if server_dependencies:
+ with_packages = list(set(with_packages + server_dependencies))
+
+ # Process environment variables if provided
+ env_dict: dict[str, str] | None = None
+ if env_file or env_vars:
+ env_dict = {}
+ # Load from .env file if specified
+ if env_file:
+ try:
+ env_dict |= {
+ k: v for k, v in dotenv_values(env_file).items() if v is not None
+ }
+ except Exception as e:
+ print(f"[red]❌ Failed to load .env file: {e}[/red]")
+ sys.exit(1)
+
+ # Add command line environment variables
+ for env_var in env_vars:
+ key, value = _parse_env_var(env_var)
+ env_dict[key] = value
+
+ # Route to appropriate installer
+ if client == Client.CLAUDE_DESKTOP:
+ success = install_claude_desktop(
+ server_spec=server_spec,
+ name=name,
+ with_editable=with_editable,
+ with_packages=with_packages,
+ env_vars=env_dict,
+ )
+ elif client == Client.CURSOR:
+ success = install_cursor(
+ server_spec=server_spec,
+ name=name,
+ with_editable=with_editable,
+ with_packages=with_packages,
+ env_vars=env_dict,
+ )
+ else:
+ print(
+ f"[red bold]Unknown client: {client!r}[/red bold]. Supported clients: [bold]{Client.CLAUDE_DESKTOP}[/bold], [bold]{Client.CURSOR}[/bold]"
+ )
+ raise typer.Exit(1)
+
+ if success:
+ # Only show generic success message for clients that don't have their own messaging
+ if client != Client.CURSOR:
+ print(
+ f"[green bold]Successfully installed '[bold]{name}[/bold]' in {client.value}[/green bold]"
+ )
+ else:
+ sys.exit(1)
+
+
+def _parse_env_var(env_var: str) -> tuple[str, str]:
+ """Parse environment variable string in format KEY=VALUE."""
+ if "=" not in env_var:
+ print(
+ f"[red]❌ Invalid environment variable format: '[bold]{env_var}[/bold]'. Must be KEY=VALUE[/red]"
+ )
+ sys.exit(1)
+ key, value = env_var.split("=", 1)
+ return key.strip(), value.strip()
diff --git a/src/fastmcp/client/client.py b/src/fastmcp/client/client.py
index 96330f3bc..6388b1c6f 100644
--- a/src/fastmcp/client/client.py
+++ b/src/fastmcp/client/client.py
@@ -31,11 +31,11 @@ from fastmcp.client.roots import (
)
from fastmcp.client.sampling import SamplingHandler, create_sampling_callback
from fastmcp.exceptions import ToolError
+from fastmcp.mcp_config import MCPConfig
from fastmcp.server import FastMCP
from fastmcp.utilities.exceptions import get_catch_handlers
from fastmcp.utilities.json_schema_type import json_schema_to_type
from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.mcp_config import MCPConfig
from fastmcp.utilities.types import get_cached_typeadapter
from .transports import (
diff --git a/src/fastmcp/client/transports.py b/src/fastmcp/client/transports.py
index 5cef53aa7..8cf90dfff 100644
--- a/src/fastmcp/client/transports.py
+++ b/src/fastmcp/client/transports.py
@@ -29,10 +29,10 @@ from typing_extensions import TypedDict, Unpack
import fastmcp
from fastmcp.client.auth.bearer import BearerAuth
from fastmcp.client.auth.oauth import OAuth
+from fastmcp.mcp_config import MCPConfig, infer_transport_type_from_url
from fastmcp.server.dependencies import get_http_headers
from fastmcp.server.server import FastMCP
from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.mcp_config import MCPConfig, infer_transport_type_from_url
logger = get_logger(__name__)
diff --git a/src/fastmcp/mcp_config.py b/src/fastmcp/mcp_config.py
new file mode 100644
index 000000000..029c802d1
--- /dev/null
+++ b/src/fastmcp/mcp_config.py
@@ -0,0 +1,282 @@
+"""Canonical MCP Configuration Format.
+
+This module defines the standard configuration format for Model Context Protocol (MCP) servers.
+It provides a client-agnostic, extensible format that can be used across all MCP implementations.
+
+The configuration format supports both stdio and remote (HTTP/SSE) transports, with comprehensive
+field definitions for server metadata, authentication, and execution parameters.
+
+Example configuration:
+ {
+ "mcpServers": {
+ "my-server": {
+ "command": "npx",
+ "args": ["-y", "@my/mcp-server"],
+ "env": {"API_KEY": "secret"},
+ "timeout": 30000,
+ "description": "My MCP server"
+ }
+ }
+ }
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated, Any, Literal
+from urllib.parse import urlparse
+
+import httpx
+from pydantic import AnyUrl, BaseModel, ConfigDict, Field
+
+if TYPE_CHECKING:
+ from fastmcp.client.transports import (
+ SSETransport,
+ StdioTransport,
+ StreamableHttpTransport,
+ )
+
+
+def infer_transport_type_from_url(
+ url: str | AnyUrl,
+) -> Literal["http", "sse"]:
+ """
+ Infer the appropriate transport type from the given URL.
+ """
+ url = str(url)
+ if not url.startswith("http"):
+ raise ValueError(f"Invalid URL: {url}")
+
+ parsed_url = urlparse(url)
+ path = parsed_url.path
+
+ # Match /sse followed by /, ?, &, or end of string
+ if re.search(r"/sse(/|\?|&|$)", path):
+ return "sse"
+ else:
+ return "http"
+
+
+class StdioMCPServer(BaseModel):
+ """MCP server configuration for stdio transport.
+
+ This is the canonical configuration format for MCP servers using stdio transport.
+ """
+
+ # Required fields
+ command: str
+
+ # Common optional fields
+ args: list[str] = Field(default_factory=list)
+ env: dict[str, Any] = Field(default_factory=dict)
+
+ # Transport specification
+ transport: Literal["stdio"] = "stdio"
+ type: Literal["stdio"] | None = None # Alternative transport field name
+
+ # Execution context
+ cwd: str | None = None # Working directory for command execution
+ timeout: int | None = None # Maximum response time in milliseconds
+
+ # Metadata
+ description: str | None = None # Human-readable server description
+ icon: str | None = None # Icon path or URL for UI display
+
+ # Authentication configuration
+ authentication: dict[str, Any] | None = None # Auth configuration object
+
+ model_config = ConfigDict(extra="allow") # Preserve unknown fields
+
+ def to_transport(self) -> StdioTransport:
+ from fastmcp.client.transports import StdioTransport
+
+ return StdioTransport(
+ command=self.command,
+ args=self.args,
+ env=self.env,
+ cwd=self.cwd,
+ )
+
+
+class RemoteMCPServer(BaseModel):
+ """MCP server configuration for HTTP/SSE transport.
+
+ This is the canonical configuration format for MCP servers using remote transports.
+ """
+
+ # Required fields
+ url: str
+
+ # Transport configuration
+ transport: Literal["http", "streamable-http", "sse"] | None = None
+ headers: dict[str, str] = Field(default_factory=dict)
+
+ # Authentication
+ auth: Annotated[
+ str | Literal["oauth"] | httpx.Auth | None,
+ Field(
+ description='Either a string representing a Bearer token, the literal "oauth" to use OAuth authentication, or an httpx.Auth instance for custom authentication.',
+ ),
+ ] = None
+
+ # Timeout configuration
+ sse_read_timeout: datetime.timedelta | int | float | None = None
+ timeout: int | None = None # Maximum response time in milliseconds
+
+ # Metadata
+ description: str | None = None # Human-readable server description
+ icon: str | None = None # Icon path or URL for UI display
+
+ # Authentication configuration
+ authentication: dict[str, Any] | None = None # Auth configuration object
+
+ model_config = ConfigDict(
+ extra="allow", arbitrary_types_allowed=True
+ ) # Preserve unknown fields
+
+ def to_transport(self) -> StreamableHttpTransport | SSETransport:
+ from fastmcp.client.transports import SSETransport, StreamableHttpTransport
+
+ if self.transport is None:
+ transport = infer_transport_type_from_url(self.url)
+ else:
+ transport = self.transport
+
+ if transport == "sse":
+ return SSETransport(
+ self.url,
+ headers=self.headers,
+ auth=self.auth,
+ sse_read_timeout=self.sse_read_timeout,
+ )
+ else:
+ # Both "http" and "streamable-http" map to StreamableHttpTransport
+ return StreamableHttpTransport(
+ self.url,
+ headers=self.headers,
+ auth=self.auth,
+ sse_read_timeout=self.sse_read_timeout,
+ )
+
+
+class MCPConfig(BaseModel):
+ """Canonical MCP configuration format.
+
+ This defines the standard configuration format for Model Context Protocol servers.
+ The format is designed to be client-agnostic and extensible for future use cases.
+ """
+
+ mcpServers: dict[str, StdioMCPServer | RemoteMCPServer]
+
+ model_config = ConfigDict(extra="allow") # Preserve unknown top-level fields
+
+ @classmethod
+ def from_dict(cls, config: dict[str, Any]) -> MCPConfig:
+ """Parse MCP configuration from dictionary format."""
+ # Handle case where config is just the mcpServers object
+ if "mcpServers" not in config and any(
+ isinstance(v, dict) and ("command" in v or "url" in v)
+ for v in config.values()
+ ):
+ # This looks like a bare mcpServers object
+ servers_dict = config
+ else:
+ # Standard format with mcpServers wrapper
+ servers_dict = config.get("mcpServers", {})
+
+ # Parse each server configuration
+ parsed_servers = {}
+ for name, server_config in servers_dict.items():
+ if not isinstance(server_config, dict):
+ continue
+
+ # Determine if this is stdio or remote based on fields
+ if "command" in server_config:
+ parsed_servers[name] = StdioMCPServer.model_validate(server_config)
+ elif "url" in server_config:
+ parsed_servers[name] = RemoteMCPServer.model_validate(server_config)
+ else:
+ # Skip invalid server configs but preserve them as raw dicts
+ # This allows for forward compatibility with unknown server types
+ continue
+
+ # Create config with any extra top-level fields preserved
+ config_data = {k: v for k, v in config.items() if k != "mcpServers"}
+ config_data["mcpServers"] = parsed_servers
+
+ return cls.model_validate(config_data)
+
+ def to_dict(self) -> dict[str, Any]:
+ """Convert MCPConfig to dictionary format, preserving all fields."""
+ # Start with all extra fields at the top level
+ result = self.model_dump(exclude={"mcpServers"}, exclude_none=True)
+
+ # Add mcpServers with all fields preserved
+ result["mcpServers"] = {
+ name: server.model_dump(exclude_none=True)
+ for name, server in self.mcpServers.items()
+ }
+
+ return result
+
+ def write_to_file(self, file_path: Path) -> None:
+ """Write configuration to JSON file."""
+ file_path.parent.mkdir(parents=True, exist_ok=True)
+ with open(file_path, "w") as f:
+ json.dump(self.to_dict(), f, indent=2)
+
+ @classmethod
+ def from_file(cls, file_path: Path) -> MCPConfig:
+ """Load configuration from JSON file."""
+ if not file_path.exists():
+ return cls(mcpServers={})
+ with open(file_path) as f:
+ content = f.read().strip()
+ if not content:
+ return cls(mcpServers={})
+ data = json.loads(content)
+ return cls.from_dict(data)
+
+ def add_server(self, name: str, server: StdioMCPServer | RemoteMCPServer) -> None:
+ """Add or update a server in the configuration."""
+ self.mcpServers[name] = server
+
+ def remove_server(self, name: str) -> None:
+ """Remove a server from the configuration."""
+ if name in self.mcpServers:
+ del self.mcpServers[name]
+
+
+def update_config_file(
+ file_path: Path,
+ server_name: str,
+ server_config: StdioMCPServer | RemoteMCPServer,
+) -> None:
+ """Update MCP configuration file with new server, preserving existing fields."""
+ config = MCPConfig.from_file(file_path)
+
+ # If updating an existing server, merge with existing configuration
+ # to preserve any unknown fields
+ if server_name in config.mcpServers:
+ existing_server = config.mcpServers[server_name]
+ # Get the raw dict representation of both servers
+ existing_dict = existing_server.model_dump()
+ new_dict = server_config.model_dump(exclude_none=True)
+
+ # Merge, with new values taking precedence
+ merged_dict = {**existing_dict, **new_dict}
+
+ # Create new server instance with merged data
+ if "command" in merged_dict:
+ merged_server = StdioMCPServer.model_validate(merged_dict)
+ else:
+ merged_server = RemoteMCPServer.model_validate(merged_dict)
+
+ config.add_server(server_name, merged_server)
+ else:
+ config.add_server(server_name, server_config)
+
+ config.write_to_file(file_path)
diff --git a/src/fastmcp/server/proxy.py b/src/fastmcp/server/proxy.py
index 6d7a6613b..53df47f74 100644
--- a/src/fastmcp/server/proxy.py
+++ b/src/fastmcp/server/proxy.py
@@ -22,6 +22,7 @@ from fastmcp.client.logging import LogMessage
from fastmcp.client.roots import RootsList
from fastmcp.client.transports import ClientTransportT
from fastmcp.exceptions import NotFoundError, ResourceError, ToolError
+from fastmcp.mcp_config import MCPConfig
from fastmcp.prompts import Prompt, PromptMessage
from fastmcp.prompts.prompt import PromptArgument
from fastmcp.prompts.prompt_manager import PromptManager
@@ -33,7 +34,6 @@ from fastmcp.server.server import FastMCP
from fastmcp.tools.tool import Tool, ToolResult
from fastmcp.tools.tool_manager import ToolManager
from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.mcp_config import MCPConfig
if TYPE_CHECKING:
from fastmcp.server import Context
diff --git a/src/fastmcp/server/server.py b/src/fastmcp/server/server.py
index 6d92e412f..1985e7c16 100644
--- a/src/fastmcp/server/server.py
+++ b/src/fastmcp/server/server.py
@@ -43,6 +43,7 @@ from starlette.routing import BaseRoute, Route
import fastmcp
import fastmcp.server
from fastmcp.exceptions import DisabledError, NotFoundError
+from fastmcp.mcp_config import MCPConfig
from fastmcp.prompts import Prompt, PromptManager
from fastmcp.prompts.prompt import FunctionPrompt
from fastmcp.resources import Resource, ResourceManager
@@ -63,7 +64,6 @@ from fastmcp.utilities.cache import TimedCache
from fastmcp.utilities.cli import log_server_banner
from fastmcp.utilities.components import FastMCPComponent
from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.mcp_config import MCPConfig
from fastmcp.utilities.types import NotSet, NotSetT
if TYPE_CHECKING:
diff --git a/src/fastmcp/utilities/mcp_config.py b/src/fastmcp/utilities/mcp_config.py
deleted file mode 100644
index 9b63f42cc..000000000
--- a/src/fastmcp/utilities/mcp_config.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from __future__ import annotations
-
-import datetime
-import re
-from typing import TYPE_CHECKING, Annotated, Any, Literal
-from urllib.parse import urlparse
-
-import httpx
-from pydantic import AnyUrl, ConfigDict, Field
-
-from fastmcp.utilities.types import FastMCPBaseModel
-
-if TYPE_CHECKING:
- from fastmcp.client.transports import (
- SSETransport,
- StdioTransport,
- StreamableHttpTransport,
- )
-
-
-def infer_transport_type_from_url(
- url: str | AnyUrl,
-) -> Literal["http", "sse"]:
- """
- Infer the appropriate transport type from the given URL.
- """
- url = str(url)
- if not url.startswith("http"):
- raise ValueError(f"Invalid URL: {url}")
-
- parsed_url = urlparse(url)
- path = parsed_url.path
-
- # Match /sse followed by /, ?, &, or end of string
- if re.search(r"/sse(/|\?|&|$)", path):
- return "sse"
- else:
- return "http"
-
-
-class StdioMCPServer(FastMCPBaseModel):
- command: str
- args: list[str] = Field(default_factory=list)
- env: dict[str, Any] = Field(default_factory=dict)
- cwd: str | None = None
- transport: Literal["stdio"] = "stdio"
-
- def to_transport(self) -> StdioTransport:
- from fastmcp.client.transports import StdioTransport
-
- return StdioTransport(
- command=self.command,
- args=self.args,
- env=self.env,
- cwd=self.cwd,
- )
-
-
-class RemoteMCPServer(FastMCPBaseModel):
- url: str
- headers: dict[str, str] = Field(default_factory=dict)
- transport: Literal["http", "streamable-http", "sse"] | None = None
- auth: Annotated[
- str | Literal["oauth"] | httpx.Auth | None,
- Field(
- description='Either a string representing a Bearer token, the literal "oauth" to use OAuth authentication, or an httpx.Auth instance for custom authentication.',
- ),
- ] = None
- sse_read_timeout: datetime.timedelta | int | float | None = None
-
- model_config = ConfigDict(arbitrary_types_allowed=True)
-
- def to_transport(self) -> StreamableHttpTransport | SSETransport:
- from fastmcp.client.transports import SSETransport, StreamableHttpTransport
-
- if self.transport is None:
- transport = infer_transport_type_from_url(self.url)
- else:
- transport = self.transport
-
- if transport == "sse":
- return SSETransport(
- self.url,
- headers=self.headers,
- auth=self.auth,
- sse_read_timeout=self.sse_read_timeout,
- )
- else:
- # Both "http" and "streamable-http" map to StreamableHttpTransport
- return StreamableHttpTransport(
- self.url,
- headers=self.headers,
- auth=self.auth,
- sse_read_timeout=self.sse_read_timeout,
- )
-
-
-class MCPConfig(FastMCPBaseModel):
- mcpServers: dict[str, StdioMCPServer | RemoteMCPServer]
-
- @classmethod
- def from_dict(cls, config: dict[str, Any]) -> MCPConfig:
- return cls(mcpServers=config.get("mcpServers", config))
diff --git a/tests/utilities/test_mcp_config.py b/tests/utilities/test_mcp_config.py
index 253b7c452..b0d5822cf 100644
--- a/tests/utilities/test_mcp_config.py
+++ b/tests/utilities/test_mcp_config.py
@@ -10,7 +10,7 @@ from fastmcp.client.transports import (
StdioTransport,
StreamableHttpTransport,
)
-from fastmcp.utilities.mcp_config import MCPConfig, RemoteMCPServer, StdioMCPServer
+from fastmcp.mcp_config import MCPConfig, RemoteMCPServer, StdioMCPServer
def test_parse_single_stdio_config():