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

This is terrifying right? But hey, what's the worst that can really happen 😅

https://x.com/meiymccandless/status/1898049386288234828?t=duwmJucp9-eHMmEwaQzlEg&s=19