Forem: Miki Makhlevich

We built a runtime for background AI agents

Miki Makhlevich — Fri, 19 Dec 2025 07:22:38 +0000

Most LLM frameworks help you talk to agents, but the most useful agents should be treated like services.

They run in the background.
They wake up on a schedule.
They react to webhooks.
They shouldn't wait for a human to manually trigger them.

That gap is why we built langchain-runner, a small runtime for deploying always-on, trigger-driven AI agents using LangChain or LangGraph.

The mental model is simple:
langchain-runner is a daemon for AI agents. You give it an agent, define what wakes it up, and it handles execution and tracking.

Here’s what that looks like in practice:

from langchain_runner import Runner
from my_agent import agent

runner = Runner(agent)

@runner.cron("0 9 * * *")
async def daily_review():
    return "Review yesterday's activity"

runner.serve()

That’s it.

You now have an agent that wakes up every morning and runs in the background. No chat UI, blocking requests or FastAPI glue.

Using webhooks as triggers is just as easy

@runner.webhook("/github")
async def on_github_event(payload: dict):
    return f"Handle GitHub event: {payload['action']}"

This creates a webhook endpoint at /webhook/github

What makes this different from existing tools is the focus on activation, not interaction.

LangServe is great when you want an API.
LangGraph is great when you want structured workflows.
Celery and Airflow are great when you want heavy orchestration.

langchain-runner is for the middle ground: small, autonomous agents that wake up because something happened.

Stop treating every agent like a chatbot.
pip install langchain-runner

👉 GitHub: https://github.com/tadata-org/langchain-runner

👉 PyPI: https://pypi.org/project/langchain-runner/

🚀 What We Learned Building FastAPI-MCP

Miki Makhlevich — Thu, 05 Jun 2025 17:37:42 +0000

A few months ago, we released FastAPI-MCP, an open-source library that converts FastAPI apps into MCP servers with zero configuration. We focused on making it easy and intuitive and the response was incredible - developers loved how easy it made MCP integration.

But with usage we started noticing developers had different issues than we originally thought.

The Problem We Didn't See Coming

"Can you help with authentication setup?"

"Can this MCP scale?"

"How do I deploy it to a separate instance?"

"How do I know if my tools are actually working well?"

"How can I tell how my MCP is being used?"

FastAPI-MCP solved the direct conversion problem beautifully. But production? That's where users had to work.

What's The Delta To Production MCP

Here's what we learned:

Hosting headaches: Where do you even deploy an MCP server? we made it easy to be deployed along side your API but managing two different beasts on the same infra might not be easy.
Authentication: Bearer tokens are easy, but OAuth takes a lot of set up from devs, even when the package supports it.
Zero observability: Are agents actually using all the tools? Is your tool description or parameters confusing the LLM? You'll never know
Scaling issues: What happens when 100 AI assistants hit your server?

API to MCP Conversion Isn't That Easy

Beyond the technical deployment challenges, we discovered deeper issues:

Tool Selection: Developers had APIs with 200+ endpoints but no idea which ones would actually be useful for AI assistants. Should they expose everything? Just the core features? How do you decide? Should we add composite tools to make life easier for the LLMs?

Description Quality: This was huge. Developers would write API documentation for humans, but AI assistants need different context. Tool descriptions that made perfect sense to developers completely confused LLMs.

Connection Complexity: How do customers actually connect to their MCP servers? While FastAPI-MCP creates SSE servers, helping customers integrate with tools like MCP-remote or custom clients was often more complex than building the server itself.

We felt like we're repeating the known pattern "easy to demo, hard to get to production".

The Platform We Wish We Had

Instead of just documenting "how to deploy FastAPI-MCP" we built the infrastructure we wish existed.

Tadata creates hosted, authenticated MCP servers with analytics in under 1 minute. Here's how it works:

# Deploy your FastAPI app
import tadata_sdk
tadata_sdk.deploy(fastapi_app=app, api_key="TADATA_API_KEY")

Or upload any OpenAPI spec - works with Django, Express, Spring Boot, whatever.

📊 The Analytics Game-Changer

Developers can finally see:

How are agents using my MCP
Which tool descriptions confuse AI assistants
Which tools never get used (and should be removed)
How to optimize based on real usage patterns instead of guessing

Two Different Solutions, Same Vision

Today we maintain both:

FastAPI-MCP: Open source, DIY hosting, full control
Tadata: Managed hosting, focus on building tools not infrastructure

They serve different needs in the MCP ecosystem.

FastAPI-MCP remains our love letter to the developer community - free, open, and powerful. Tadata is for developers who want to skip the operational headache and get straight to building great AI tools.

What's Next?

The MCP ecosystem is exploding, and we want to help everyone get the most out of their existing APIs.

If you need production-ready hosting without the hassle, check out Tadata.

The AI revolution is happening. Your software should be part of it 🤖

The Very First MCP Generator to Support Auth!

Miki Makhlevich — Tue, 22 Apr 2025 15:43:51 +0000

🚀 Revolutionary! Secure your AI-driven apps with the first-ever MCP server generator that includes auth support. Yes, you read that right. Auth is finally here for Model Context Protocol (MCP) in Python!

In today’s AI-driven world, you need your app to interact with intelligent agents—and security is a must. That’s why we’re excited to introduce the first Python-based MCP generator to offer native authentication. Now you can make sure only trusted users (or agents!) can access your powerful app features.

All of this is possible through using FastAPI-MCP, a tool to convert any FastAPI to MCP server in python using 2 lines of code, starred by 3.5K GitHub users in less than a month!

Why Should You Care?

👉 Unlock Seamless AI Interactions: Build apps that talk with AI agents securely and efficiently.
👉 Boost Security: Built-in authentication means you’re not just exposing an API, but securing your app from unauthorized access.
👉 Simplified Setup: The fastapi-mcp library make it easier than ever to create robust and secure MCP servers. No complex configurations, 2 lines of code, just plug-and-play

Ready to Get Started?

Building the future of secure AI interactions has never been this easy. Follow along the ultimate guide to create an MCP server with authentication in just a few simple steps, and Don't forget to star the repo! 🌟

Plus, contribute! Help us improve this tool, report bugs, and propose new features. We’re all about community-driven growth!

What’s Coming Next?

🔥 Streamable HTTP Transport: The future of MCP communication—soon to be implemented for faster and more efficient connections, in line with the latest spec.
🔥 Custom MCP tools and resources: Adding support for custom MCP tools and resources, independent of your FastAPI endpoints. It’s the natural next step for expanding your MCP server’s capabilities.

🔥 Only 2 Lines of code to create an MCP server from a FastAPI - Major updates 🚀

Miki Makhlevich — Thu, 10 Apr 2025 15:09:47 +0000

Just released a huge update to FastAPI-MCP, our zero-configuration tool that lets you expose FastAPI endpoints as Model Context Protocol (MCP) tools with a completely revamped architecture! Only 2 lines of code and you have a configurable and reliable MCP server!

Two Powerful Improvements You Need To Know About:

🎯 NEW: Selective Endpoint Exposure

We had such great adoption, which came with a lot of requests and pressure to support this feature. You asked, we delivered! Now you can precisely control which endpoints become MCP tools with simple include/exclude configurations.

💪 Class-Based Architecture For Better Extensibility

We've completely refactored the implementation to use a new FastApiMCP class for better usability and extensibility. This gives you more control and prevents edge-case in complex FastAPI configurations. No more frustration over endless bugs!

Implementation Is Still Super Simple:

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

app = FastAPI()

mcp = FastApiMCP(app)

# Mount the MCP server directly to your FastAPI app
mcp.mount()

To control which endpoints are exposed, play with the FastApiMCP arguments:

include_operations
exclude_operations
include_tags
exclude_tags

This update is available now on PyPI!

Finally

You can read more about our refactor journey here.
Don't forget to star our repo FastAPI-MCP !

I Tested Every MCP Client So You Don't Have To 🔥

Miki Makhlevich — Sun, 06 Apr 2025 13:08:35 +0000

Listen up, developers! 👀 I just spent DAYS diving into the MCP rabbit hole so you can save your precious time. If you're building AI apps, this is the guide you've been searching for.

The Quick MCP Rundown

MCP servers connect AI agents to apps through structured communication. They're the translators making AI actually useful in real applications.

The Client Showdown: What Nobody Tells You

Here's where it gets juicy. The CLIENT side is where everyone's getting it wrong! 🔥
I've personally checked EVERY. SINGLE. MCP client out there, and let me tell you — they are NOT created equal. Some will waste your time, while others are absolute gems that'll supercharge your development.
Skip to the end for my no-BS recommendations based on what you actually need.
Updated regularly! Found something missing? Comment below for quick updates!

Engineers? These Are Your Go-To Clients 👨‍💻

Claude Desktop

The Official Solution
✅ Native MCP support
✅ Easy configuration
❌ Requires technical setup

Quick Setup:
Settings → Developer → Edit Config

{  
  "mcpServers": {  
    "mcp-server-name": {  
      "command": "npx",  
      "args": [  
        "required",  
        "args"  
      ]  
    }  
  }  
}

💡 Pro Tip: Always restart Claude after saving!

Claude Code

The Command-Line Champion
✅ Supports both SSE & stdio
✅ Lightweight interface
❌ No Resources support

Lightning-Fast Setup:
For stdio:

claude mcp add <name> <command> [args...]

For SSE:

claude mcp add --transport sse <name> <url>

Cursor

The Developer's Dream IDE
✅ First code editor with MCP
✅ Supports SSE transport
✅ Seamless coding integration

Quick Setup:
Settings → MCP → Add a new MCP server
For stdio - see JSON as in Claude Desktop. For SSE:

{  
  "mcpServers": {  
    "mcp-server-name": {  
      "url": "http://the/url/to/your/mcp"  
    }  
  }  
}

Cline

The VSCode Powerhouse
✅ Open-source AI agent
✅ Marketplace support
✅ Maintains existing workflow

Quick Setup:
MCP Servers tab → Select provider

Or configure custom with the same JSON patterns you already know:
MCP Servers → Installed → Configure MCP Servers

Windsurf by Codeium

The Robust Alternative
✅ Familiar configuration
✅ Advanced integration

Quick Setup:
Settings → Advanced Settings or via Command Palette → Windsurf Settings → Cascade → View raw config

⚠️ MCP server name should NOT start with @

Goose CLI

The Beginner-Friendly Terminal
✅ Intuitive approach
✅ No manual JSON editing
✅ Desktop version available

Quick Setup:

goose configure

Then select Add Extension and follow prompts (Command-line Extension for stdio, Remote Extension for SSE).

Non-Engineers? The Painful Truth 😩

There's a MASSIVE gap in the market right now. Claude Desktop is basically your only option, and even that requires technical knowledge (as it only supports stdio which requires locally running the server).

Even the MCP experts are struggling with this:

Know something I don't? Drop it in the comments!

The Hidden Gems Most People Miss 💎

These clients adopted MCP early but don't get enough credit:

Continue — s VSCode / JetBrains extension. Although still considered experimental, have full supports for all MCP features.
5ire — an AI assistant and MCP client. Has built in MCPs under Tools (right panel), supporting only stdio (command) transport clients, or connecting clients from the marketplace they provide.
Zed — a code editor. Currently only supporting MCPs as Zed extensions, having only one MCP extension for Postgres.
Copilot-MCP — a VSCode extension. Dedicated to integrate MCPs with GitHub Copilot Chat.
LibreChat — open-source app compatible with any AI provider. Supports MCPs as Tools.
GenAIScript — a JavaScript tool to programmatically assemble prompts for LLMs, MCP servers can be configured in the defTool, using the same syntax as the Claude JSON.
Emacs Mcp.el — Emacs client for interacting with MCP servers. Supporting structured communication, asynchronous operations, and integration with popular Emacs packages.
oterm — a text-based terminal client for Ollama (that does not yet support MCPs, but the tool attempts to bridge the servers with it). Adding servers is done in the config.json similarly to the Claude JSON.
Sourcegraph Cody — a VSCode extension that performs as AI coding assistant. Requires editing your VSCode JSON settings.
Witsy — a desktop AI assistant, requires API keys for LLM providers. Supports only outsourced MCP servers providers (not suitable for local MCPs), Configure the MCPs in Settings → Plugins → MCP.
Theia AI/IDE by EclipseSource — a platform for building custom Cloud & Desktop IDEs and tools. Currently supports only stdio.
Tester MCP client by Apify — connects to any MCP server using SSE, designed for testing the MCP server.

BONUS: Agent-Building Tools That Support MCP 🤖

BeeAI Framework — open-source framework to implement multi-agent patterns. To connect to MCP it requires programming the connection in python or TypeScript. Found a useful example in this blog post.
SpinAI — a TypeScript framework for creating AI agents. Can add MCPs from outsourced providers using the command line (not suitable for local MCPs).
Fast-Agent — a lightweight framework for creating and managing agents and workflows using MCP, supporting all the features.
mcp-agent — a python based library to help you build AI agents that supports MCPs.
Microsoft Copilot — a graphical, low-code tool for building agents and agent flows, allows connecting MCP servers only through SSE and still in testing and trial (only in preview regions).
core by OpenSumi- an MCP client, framework to build AI Native IDE products.

The Bottom Line: My No-BS Recommendations ⚡

Best for SSE: Cursor or Cline
Best CLI: Claude Code or Goose
Best for GitHub Users: Copilot-MCP
Best for Testing: Apify MCP tester

What's Next for MCP?

MCPs are about to EXPLODE in popularity. Early adopters will have the advantage as this becomes industry standard.

Want to stay ahead? Join the MCParty Slack Community for insider updates.

Found a mistake? Let me know in the comments and I'll update within 24 hours!

Written in collaboration with Shira Ayal.

Less than a minute to convert MCP transport from SSE to stdio! 💻

Miki Makhlevich — Sun, 06 Apr 2025 11:53:58 +0000

A while ago someone asked in the MCParty Slack Community (a community designated to sharing thoughts, ideas and problems regarding building and using MCP) a very good question:

My MCP has URL connection, how do I connect it to Claude Desktop?

Whether you just started building your own MCP server from scratch or you found helpful tools to convert your existing applications to MCP servers (such as fastapi-mcp, see my guide on how to do that easily), you must know by now that your AI agent needs to connect to your MCP by one of two communication options (while Anthropic recently updated their protocol to use Streamable HTTP, many still use SSE so I am writing in relation to the original implementation):

SSE (Server-Sent Events) — pushing data to a client over a single HTTP connection. It’s a real-time, one-way communication from server to client. This is the URL connection he asked about.
stdio (Standard Input/Output) — a local integration not specific to web technologies (not tied to any specific network protocol), with lower latency.

You must have asked yourself — why choose one over the other?

MCP servers should use stdio for local integrations (often simpler to set up and use, also the recommended method by Anthropic), while SSE is better suited for distributed systems requiring multi-client support and remote access.

But here come’s the challenge — what can you do if your MCP is using SSE (because you downloaded it from a remote place), and you want to connect it to Claude Desktop, which currently supports only stdio?

After trying out three other possible solutions that didn’t work, I found the ONE that actually did the job: mcp-proxy by @sparfenyuk — an open-source project (I ❤️ open-source).

How to Use mcp-proxy

The implementation is surprisingly straightforward. Here’s a step-by-step guide:

Installation

First, install the library using:

uv tool install mcp-proxy

Configure Claude Desktop

Open Claude Desktop, then nabivate to:

File → Settings → Developer → Edit config

A JSON configuration file will open. Enter the appropriate settings to specify the path to your MCP.

If you used fastapi-mcp to convert an existing FastAPI application to an MCP server, your SSE URL is likely http://127.0.0.1:8000/mcp.

{
  "mcpServers": {
    "my-api-mcp-proxy": {
        "command": "mcp-proxy",
        "args": ["http://path/to/mcp/sse"]
    }
  }
}

Note for MacOS users: you might need to use the full-path to your mcp-proxy executable, which can be found by running in Terminal: which mcp-proxy.

Don’t forget to quit Claude after you saved the configuration!

Accessing Your Tools

Finally, open Claude Desktop and discover all your tools:

Notice that you will need to approve the usage of the MCP before Claude can run it.

Troubleshooting Tips

If you don’t see your tools after configuration:

Verify your MCP server is running
Check that the URL in your configuration matches your SSE endpoint exactly
Ensure mcp-proxy was installed correctly
Review Claude Desktop logs for any connection errors

The fine print (Additional Considerations)

When using mcp-proxy to convert SSE to stdio (or vice versa), remember that you’re creating a bridge between different communication protocols. Aside from latency differences — error handling approaches might need adjustment. Additionally, ensure you consider these important security considerations:

Your MCP server implements proper authentication if needed
The communication happens over a secure connection if handling sensitive data
You’re aware of any rate limiting or timeout settings in your MCP implementation

While these considerations might alarm you, remember that the beauty of this solution is in its simplicity. By using mcp-proxy, you’ve effectively bridged the gap between SSE and stdio, allowing your Claude Desktop client to communicate seamlessly with your existing MCP infrastructure!

Written in collaboration with Shira Ayal.

How to build MCP server in python using FastAPI

Miki Makhlevich — Thu, 27 Mar 2025 15:48:03 +0000

I’ve seen many people intimidated or confused by the new MCP protocol published by Anthropic, which is designed to make the connection between an AI agent and your application seamless and clear. But building such a server for your Python application doesn’t need to be complicated at all.
Before we jump in, let me convince you why it’s necessary.

The WHY

Allows AI agents to integrate with your application
Shifts complexity from human developers to AI agents, potentially streamlining application development
Simplifies the process of connecting AI to numerous tools and data sources

If MCP becomes the next standard, you’ll have no choice but to adopt it, as people will shift from manual integrations to AI doing everything for them.
Now you might say, “No problem! That’s a big if, let’s wait and see.” But once you see how little effort it takes to adopt, you’ll want to stay ahead of the curve.

The HOW

Create a FastAPI Server with the Desired Functionalities

(If you already have one, skip ahead)

The FastAPI first-steps tutorial will surely be better than mine, but here’s the gist of it:

Install dependencies:
```
pip install uvicorn, fastapi
```

Create a FastAPI server:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "MCP is super cool"}

For each functionality of your app, write a “path operation” — a function assigned to a specific path (here you see the root function under the path /), performing an HTTP operation (GET, POST, PUT, DELETE…).
Run your app using uvicorn:
```
uvicorn main:app - reload
```

That’s it! Your FastAPI app is available at http://127.0.0.1:8000. Now let’s upgrade it to an MCP server.

From FastAPI to MCP server

Install the fastapi-mcp open-source tool:
```
pip install fastapi-mcp
```

Add to your FastAPI code:

from fastapi import FastAPI
from fastapi_mcp import add_mcp_server

# Your FastAPI app
app = FastAPI()

# Mount the MCP server to your app
add_mcp_server(
    app,                 # Your FastAPI app
    mount_path="/mcp",   # Where to mount the MCP server
    name="My API MCP",   # Name for the MCP server
)

That’s it! The MCP server is auto-generated and available at http://127.0.0.1:8000/mcp. This is an address that can be configured in Cursor (or any AI agent supporting SSE, rumor has it that Cline support for MCP is on its way).

Using the MCP

Configure your MCP in Cursor:

Settings -> MCP -> Add new MCP

Paste this in the JSON file that opens:

{
  "mcpServers": {
    "My First MCP server": {
      "url": "http://127.0.0.1:8000/mcp"
      }
    }
  }

Configuring in Claude Desktop takes one more step (as it currently only supports stdio), but don’t worry — I will show you how to do it in a different post.

What’s Next?

Once set up, AI agents can now interface with your application through a standardized protocol. You can expand your MCP server by adding more endpoints that expose different functionalities of your application.
Remember, the goal of MCP is to make integration simple — so don’t overcomplicate it! Start with basic functionality and expand as needed.
The beauty of using FastAPI with the fastapi-mcp library is that you maintain all the benefits of FastAPI (like automatic documentation and type validation) while adding MCP capabilities with minimal additional code.
Let me know if you tried it, and don’t forget to star the fastapi-mcp repository!

Written in collaboration with Shira Ayal.

Forem: Miki Makhlevich

We built a runtime for background AI agents

🚀 What We Learned Building FastAPI-MCP

The Problem We Didn't See Coming

What's The Delta To Production MCP

API to MCP Conversion Isn't That Easy

The Platform We Wish We Had

📊 The Analytics Game-Changer

Two Different Solutions, Same Vision

What's Next?

The Very First MCP Generator to Support Auth!

Why Should You Care?

Ready to Get Started?

What’s Coming Next?

🔥 Only 2 Lines of code to create an MCP server from a FastAPI - Major updates 🚀

Two Powerful Improvements You Need To Know About:

🎯 NEW: Selective Endpoint Exposure

💪 Class-Based Architecture For Better Extensibility

Implementation Is Still Super Simple:

Finally

I Tested Every MCP Client So You Don't Have To 🔥

The Quick MCP Rundown

The Client Showdown: What Nobody Tells You

Engineers? These Are Your Go-To Clients 👨‍💻

Claude Desktop

Claude Code

Cursor

Cline

Windsurf by Codeium

Goose CLI

Non-Engineers? The Painful Truth 😩

The Hidden Gems Most People Miss 💎

BONUS: Agent-Building Tools That Support MCP 🤖

See also

The Bottom Line: My No-BS Recommendations ⚡

What's Next for MCP?

Less than a minute to convert MCP transport from SSE to stdio! 💻

How to Use mcp-proxy

Installation

Configure Claude Desktop

Accessing Your Tools

Troubleshooting Tips

The fine print (Additional Considerations)

How to build MCP server in python using FastAPI

The WHY

The HOW

Create a FastAPI Server with the Desired Functionalities

From FastAPI to MCP server

Using the MCP

What’s Next?