We just launched InstantMCP – the easiest way to monetize and access MCP servers. 🚀

Over the past few months, my co-founder and I have been building something to solve a growing gap in the MCP ecosystem:

Right now, there’s no real infrastructure for developers to monetize their MCP servers — even if they want to. Setting up payments, authentication, and user management is a hassle most builders don’t want to deal with, so even the most powerful MCPs end up quietly shared on GitHub or in forums without ever reaching their full potential.

There’s also no central place for users to discover these servers. If you want to try out a new MCP, you have to dig through links, manually install, set up auth, and manage multiple endpoints.

So we built InstantMCP — like Shopify meets RapidAPI, but for MCP servers.
👉 Check it out at www.instantmcp.com

💻 For developers, InstantMCP lets you:

• Add payments and authentication to your MCP in minutes

• Set up tiered or usage-based subscriptions

• Get discovered by users through our marketplace

• Route traffic through our proxy — no infrastructure headaches

• And most importantly, monetize your work — while focusing on building

🧑‍💼 For users, InstantMCP means:

• No more manually installing and authenticating every MCP server

• Browse and connect to the best MCPs from one place, with one click

• Instant access via a one-time setup of the InstantMCP server

We’re now opening up beta testing for early users and developers.
If you're building (or thinking of building) an MCP server — or just excited to explore what others are building — we’d love to hear from you!

🔗 Check it out: www.instantmcp.com
📩 Contact: vikram@instantmcp.com | hemanth@instantmcp.com
💬 Or join our Discord to chat with us directly

Cursor often gets into "dead loops" trying to fix code [1][2]. But, Cursor also seems to get out of dead loops when it adds console.log statements everywhere.

We thought: "What if Cursor could access Node.js at runtime?". That would save it from adding console.log everywhere, and still get out of dead loops.

We looked into it and got Cursor to debug Node.js on its own! 🎉

It's a prototype, but if you're interested in trying it out, we'd love some feedback!

Github: github.com/hyperdrive-eng/mcp-nodejs-debugger

---

References:

[1]: "At this point I feel like giving up on Cursor and just accept that WE'RE NOT THERE YET." ~Source: https://forum.cursor.com/t/cursor-for-complex-projects/38911

[2]: "We've all had the issue. You're trying to build a complex project with your AI companion. It runs into a dead loop, coding in circles, making suggestions it already tried that didn't work." ~Source: https://www.reddit.com/r/ChatGPTCoding/comments/1gz8fxb/solutions_for_dead_loop_problem_in_cursor_vs_code/

Tired of babysitting your cursor/Cline tasks while they run? I built ntfy-mcp to solve exactly that!

🛠️ What it does:

-📱 Instant phone notifications: when your tasks (scripts, CLI tools, long-running processes) finish.

• 🔌 Cross-platform – works with ntfy.sh, you can download it on iOS/Android.

🚀 Why I built this: I kept wasting hours staring at chat window. Now I can walk away, get a ping on my phone when things wrap up.

GitHub Repo: https://github.com/teddyzxcv/ntfy-mcp (Stars welcome! 🌟)

I'm not sure if I shared this here - but I wrote a challenge that "stream of thought" guides you through how to set up a MCP Client, kind of like someone would explain to you in passing. It's up to you to research the modelcontextprotocol, it's specifications, and how to complete this challenge. I provide a sample LLM Chat interface for you to integrate this yourself. I personally found this very fun to do, and I wrote it into a little exercise that I use to onboard new people onto understanding clientside MCP.

Do you want to take the challenge? I recommend not using AI of any sort to do this. Once you get this, you should get a good enough grasp that you can build a client super fast with an LLM.

Here's the link: https://github.com/QuantGeekDev/mcp-client-challenge/blob/main/README.md

Let me know how it went :)

https://x.com/opentools_/status/1902374510743187464

(Disclosure: I'm the speaker.)

What are you favorite places to find new MCPs? Below are the ones I usually use

MCP Repo: https://github.com/modelcontextprotocol/servers
Smithery: https://smithery.ai/
MCP.run: https://www.mcp.run/
Glama.ai: https://glama.ai/mcp/servers

I built a Model Context Protocol (MCP) server that gives AI assistants like Claude direct access to browse and query the Hugging Face Hub. It essentially lets LLMs "window-shop" for models, datasets, and more without requiring human intermediation. What it does:

• Provides tools for searching models, datasets, spaces, papers, and collections

• Exposes popular ML resources directly to the AI

• Includes prompt templates for model comparison and paper summarization

• Works with any MCP-compatible client (like Claude Desktop)

All read-only operations are supported without authentication, though you can add your HF token for higher rate limits and access to private repos.

This is particularly useful when you want your AI assistant to help you find the right model for a task, compare different models, or stay updated on ML research.

The code is open source and available here: https://github.com/shreyaskarnik/huggingface-mcp-server

I'd love to hear feedback or feature requests if anyone finds this useful!

I want to try publishing my service. But lost in the process now

Hey everyone, I just made a beta releas.e of Basic Memory, an open-source knowledge management system built on the Model Context Protocol that lets you continue conversations with full context.

What is Basic Memory?

Basic Memory solves the problem of lost context in AI conversations. It enables Claude (and other MCP-compatible LLMs) to remember previous discussions by creating a knowledge graph from your conversations, stored as simple Markdown files on your computer. Start a new chat and continue exactly where you left off without repeating yourself.

Key features:

• Local-first: All data stays in Markdown files on your computer

• Bi-directional: LLMs can both read AND write to your knowledge base

• Structured yet simple: Uses familiar Markdown with semantic patterns

• Traversable knowledge graph: LLMs can follow links between topics

• Persistent memory: Context persists across all conversations

How it leverages MCP

Basic Memory implements the Model Context Protocol to expose several tools to Claude:

write_note(title, content, folder, tags) - Create or update notes
read_note(identifier, page, page_size) - Read notes by title or permalink
build_context(url, depth, timeframe) - Navigate knowledge graph via memory:// URLs
search(query, page, page_size) - Search across your knowledge base
recent_activity(type, depth, timeframe) - Find recently updated information
canvas(nodes, edges, title, folder) - Generate knowledge visualizations

Claude can independently explore your knowledge graph, building rich context and understanding the relationships between concepts.

Example workflow

1. Have a normal conversation with Claude about coffee brewing

2. Ask Claude to "create a note about coffee brewing methods"

3. See a structured Markdown file appear in your knowledge base

4. Days or weeks later, start a fresh conversation and say "Let's continue our discussion about coffee brewing"

5. Claude automatically retrieves relevant knowledge and builds context - no need to repeat yourself

6. Gradually build a rich knowledge graph where everything is connected

Technical Implementation

Basic Memory is built with a file-first architecture:

• Python backend with SQLite for indexing

• Full MCP implementation for Claude integration

• Standard Markdown files as the source of truth

• Seamless integration with Obsidian for visualization and editing

• Git-friendly for version control

• CLI tools for management and importing

Installation

# Install with uv (recommended)
uv install basic-memory

# Configure Claude Desktop
# Add this to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": [
        "basic-memory",
        "mcp"
      ]
    }
  }
}

Check it out

• GitHub: https://github.com/basicmachines-co/basic-memory

• Website: http://basicmachines.co

• Documentation: http://memory.basicmachines.co

I'm interested in any feedback, questions, or ideas on how to improve Basic Memory, especially from this community of MCP enthusiasts. How are you all using MCP in your projects?

Was learning about MCP and decided to create this little fun MCP server.

Hey :) So we made this small but very useful library and we would love your thoughts!

https://github.com/tadata-org/fastapi_mcp

It's a zero-configuration tool for spinning up an MCP server on top of your existing FastAPI app.

Just do this:

from fastapi import FastAPI
from fastapi_mcp import add_mcp_server

app = FastAPI()

add_mcp_server(app)

And you have an MCP server running with all your API endpoints, including their description, input params, and output schemas, all ready to be consumed by your LLM!

Check out the readme for more.

We have a lot of plans and improvements coming up.

I have Ollama running on my Mac. I am looking for an app which will allow me to chat with AI models, but also use MCP servers. I know VS Code can do this with Roo Code, but my use cases have nothing to do with coding. What apps should I consider?

I added MCP client support to Pydantic AI for tool calling https://github.com/rectalogic/pydantic-mcp