DEV Community: Rumblingb

The AgentPay Catalog: 56 Products That Actually Work Now

Rumblingb — Wed, 13 May 2026 08:33:42 +0000

After our recent QA audit and fixes across the MCP server portfolio, we're proud to announce that our full product catalog is live and verified. Here's the complete rundown of what we offer, what we fixed, and what's new.

The Numbers

56 products across 3 major categories, all passing QA checks and production-ready.

Category Breakdown

MCP Servers (16 products)

Our core offering — Model Context Protocol servers that give AI agents access to real infrastructure:

mcp-server-stripe — Full Stripe integration (payments, subscriptions, disputes, customers, products). 31 broken documentation links fixed.
mcp-server-supabase — Database operations, migrations, edge functions, branches, and logging.
mcp-server-cloudflare — Workers, KV, R2, D1, Queues, Durable Objects, and DNS management.
mcp-server-search — Universal search across documentation, code, and web sources.
mcp-server-filesystem — Secure file operations with sandboxed path restrictions.
mcp-server-github — Repository management, issues, PRs, and code search.
mcp-server-social — Cross-platform social media publishing (Twitter, LinkedIn, TikTok, Instagram, YouTube, and more).
mcp-server-devto — Dev.to article publishing via MCP.
mcp-server-railway — Deploy and manage Railway projects.
Plus 7 more specialized servers.

SaaS Tools (28 products)

Ready-to-use cloud services:

AgentPay Payments Dashboard
Supabase Project Manager
Cloudflare Infrastructure Console
GitHub Automation Suite
Social Media Scheduler
23 other purpose-built tools

Developer Tools (12 products)

Libraries, CLIs, and frameworks:

@agentpayxyz npm package
Python SDK
CLI audit framework (new!)
Docker images for all MCP servers
8 plugin/integration packages

What Was Fixed

Our QA pass caught and fixed:

Import path errors in 3 MCP servers (outdated SDK imports)
asyncio runtime errors in 2 servers (sync/async pattern mismatches)
31 broken Stripe documentation links returning 403
Missing error handling in 5 tool endpoints
Inconsistent response formats across 8 tools

Every fix was tested in a staging environment before promotion to production.

What's New

Since our last catalog update, we've added:

mcp-server-devto — Because we believe in eating our own dogfood. This article was written and published via an MCP server.
Audit Framework CLI — Open-source tool for running the same QA checks on any MCP deployment.
Container images — All servers ship as Docker images for easy self-hosting.
Unified authentication — Single API key across all 56 products.

The Stack

All products are built on:

Python 3.12 with the MCP SDK v1.0+
TypeScript/Node.js for the frontend SDK
Docker for containerization
GitHub Actions for CI/CD
Stripe for payment processing
Supabase for data persistence
Cloudflare Workers for edge compute

Get Started

Browse the full catalog and start building with AI agents:

Product Catalog: Coming soon to agentpay.dev
GitHub: github.com/Rumblingb
npm: @agentpayxyz
Stripe Integration: Direct via our mcp-server-stripe

56 products, one unified platform. AgentPay — AI-native payments and infrastructure.

We Fixed All Our MCP Servers: Here's What Broke and How

Rumblingb — Wed, 13 May 2026 08:33:38 +0000

Last week, we did something we should have done months ago: a full QA audit of our MCP server portfolio. We maintain a collection of Model Context Protocol servers that power AgentPay — an AI-native payments platform built on the MCP standard. The result? We found broken imports, missing asyncio patterns, and 31 dead Stripe links. Here's the full story.

The Scope: 5 MCP Servers

Our QA pass covered five core MCP servers:

mcp-server-stripe — Payment processing via Stripe
mcp-server-supabase — Database and auth operations
mcp-server-cloudflare — Edge functions and infrastructure
mcp-server-search — Web and documentation search
mcp-server-filesystem — File management

Each server had been built at different times, with different SDK versions, by different contributors. That was the root cause.

The Audit Approach

We used a two-pronged audit strategy:

1. AST Parsing

We ran Python's ast module across every server to statically analyze:

Import statements (looking for ModuleNotFoundError candidates)
Function signatures (checking for async def vs def mismatches)
Decorator patterns (MCP tools decorated with @mcp.tool() but not awaiting properly)

2. Runtime Checks

We spun up each server in a sandboxed environment and tested every tool endpoint. This caught:

Import errors that only surface at runtime (circular imports, conditional imports with wrong fallbacks)
Stripe API links returning 403 errors
Event loop issues with asyncio.run() called inside async contexts

The Specific Fixes

Import Paths (Found in 3 servers)

The MCP SDK had undergone a major version bump from 0.4.x to 1.0.x, and import paths changed. The old from mcp.server import Server became from mcp import Server. Three servers still used the old paths.

Fix: Updated all import paths to match the SDK v1.0 convention. We also added a CI check that runs python -c "import <server>" on every PR.

asyncio Patterns (Found in 2 servers)

Two servers had mixed sync/async patterns. A def handler was calling asyncio.run() to run async code, but the MCP framework was already running inside an async event loop. This caused RuntimeError: asyncio.run() cannot be called from a running event loop.

Fix: Converted those handlers to async def and used await directly. For cases where we needed to call sync code from async contexts, we used asyncio.to_thread().

Stripe Link Fix (31 links were 403)

Our mcp-server-stripe had documentation links embedded in tool descriptions pointing to the Stripe API reference. When Stripe revamped their docs site, the URL structure changed. 31 out of 42 links returned 403 errors.

Fix: We crawled the Stripe docs using their sitemap, mapped old URLs to new ones, and updated all 31 broken links. We now run a weekly link checker to prevent this from happening again.

The Lesson: SDK Versioning Matters

The biggest takeaway from this audit is simple: pin your SDK versions and test on upgrade. MCP is still evolving rapidly, and the SDK breaking changes between minor versions are real. We now:

Pin mcp>=1.0,<2.0 in all pyproject.toml files
Run pip list --outdated weekly
Have a GitHub Action that spins up each server and tests 3 random tools on every PR

What's Next

We're open-sourcing our audit framework as a standalone MCP server so others can run the same checks on their own MCP deployments. If you maintain MCP servers, we highly recommend doing a full QA pass — you might be surprised what you find.

AgentPay is an AI-native payments platform. Check out our npm package at @agentpayxyz and our GitHub at github.com/Rumblingb.

25 Free MCP Servers for AI Agent Builders: A Curated Directory

Rumblingb — Wed, 13 May 2026 06:34:49 +0000

What is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI agents connect with external tools, data sources, and services. Think of it as a USB-C port for AI — one standardized interface, infinite capabilities.

As an AI agent builder, MCP servers are your secret weapon. Instead of building integrations from scratch, you plug in pre-built servers that handle everything from web scraping to database queries to email management.

Here's our curated list of 25 free MCP servers — all open-source, ready to go, and battle-tested.

🔧 Agent Infrastructure

1. Agent Cost Tracker MCP

Track AI agent token usage, API costs, and set budget alerts. Integrates with Stripe for billing and monetization.

GitHub: github.com/Rumblingb/agent-cost-tracker-mcp
Pro: $19/mo with Stripe billing → Subscribe

2. Agent Memory MCP

Persistent key-value memory for AI agents with TTL-based expiry and full-text search. Never lose context again.

GitHub: github.com/Rumblingb/agent-memory-mcp
Pro: $19/mo with cloud sync → Subscribe

3. Agent Wallet MCP

Wallet and budget management for agents. Send transfers, generate invoices, manage balances.

GitHub: github.com/Rumblingb/agent-wallet-mcp

4. Agent Contract MCP

Smart contracts between agents — deliverables, penalties, and automated settlements.

GitHub: github.com/Rumblingb/agent-contract-mcp

5. Agent Proof MCP

Cryptographic proof of agent work. Create and verify receipts for agent actions.

GitHub: github.com/Rumblingb/agent-proof-mcp

6. Agent Audit MCP

Immutable audit trail for agent-to-agent interactions using SHA-256 hash chains.

GitHub: github.com/Rumblingb/agent-audit-mcp

7. Agent Messaging MCP

Agent-to-agent messaging protocol. Send, reply, and manage proposals between agents.

GitHub: github.com/Rumblingb/agent-messaging-mcp

8. Agent Team MCP

Multi-agent team formation. Define roles, assign tasks, manage dependencies across agent teams.

GitHub: github.com/Rumblingb/agent-team-mcp

9. Agent Passport MCP

Agent identity and reputation system for A2A communication. Passports, skills, ratings.

GitHub: github.com/Rumblingb/agent-passport-mcp

10. Agent Hire MCP

Agent hiring marketplace. Post tasks, receive bids, manage escrow, handle disputes.

GitHub: github.com/Rumblingb/agent-hire-mcp

🌐 Web & Data

11. Wikipedia MCP

Full Wikipedia access — search, read, and explore 6.8M+ articles. Zero API keys required.

GitHub: github.com/Rumblingb/wikipedia-mcp

12. Web Scraper MCP

Extract text, links, images, and email addresses from any webpage. Free tier with no API key.

GitHub: github.com/Rumblingb/web-scraper-mcp

13. Search Proxy MCP

DuckDuckGo-powered web search for AI agents. Free tier, no API key needed.

GitHub: github.com/Rumblingb/search-proxy-mcp

14. HackerNews MCP

Browse HackerNews stories, comments, and user profiles directly from your agent.

GitHub: github.com/Rumblingb/hackernews-mcp

15. Weather MCP

Current weather, forecasts, and conditions for any location. Free tier included.

GitHub: github.com/Rumblingb/weather-mcp

💰 Finance & Business

16. Currency Exchange MCP

Real-time exchange rates for 166 currencies. Zero API keys, unlimited queries on free tier.

GitHub: github.com/Rumblingb/currency-exchange-mcp

17. Crypto Market MCP

CoinGecko-powered crypto prices, trends, and historical data. Completely free.

GitHub: github.com/Rumblingb/crypto-market-mcp

18. SEC EDGAR MCP

Access SEC EDGAR financial data — income statements, balance sheets, cash flow, and financial ratios for 10,000+ US public companies.

GitHub: github.com/Rumblingb/sec-edgar-mcp

19. SEC Financial MCP

XBRL financial facts and GAAP metrics from SEC filings. Free + Pro tier.

GitHub: github.com/Rumblingb/sec-financial-mcp

🛠️ Developer Tools

20. Database MCP

Query SQLite, PostgreSQL, and MySQL databases from your AI agent. Full CRUD support.

GitHub: github.com/Rumblingb/database-mcp

21. File Converter MCP

Convert between CSV, JSON, YAML, and Markdown formats. Zero dependencies.

GitHub: github.com/Rumblingb/file-converter-mcp

22. MCP Config Generator

Generate MCP server configs for Claude Desktop, VS Code, and Cursor with one command.

GitHub: github.com/Rumblingb/mcp-config-generator

23. MCP Health Monitor

Check server uptime, response times, and TLS certificate timing. Essential for production monitoring.

GitHub: github.com/Rumblingb/mcp-health-monitor

24. QR Code MCP

Generate and decode QR codes. Style with logos, customize colors. Free + Pro.

GitHub: github.com/Rumblingb/qr-code-mcp

25. Screenshot MCP

Take website screenshots — desktop, mobile, and element capture modes.

GitHub: github.com/Rumblingb/screenshot-mcp

🎯 How to Get Started

Pick a server from the list above
Clone the repo and install dependencies
Add to your MCP client config (Claude Desktop, Cline, Cursor, etc.)
Start building — your agent now has superpowers

Example: Claude Desktop Config

{
  "mcpServers": {
    "wikipedia": {
      "command": "python",
      "args": ["-m", "wikipedia_mcp"]
    },
    "hackernews": {
      "command": "python",
      "args": ["-m", "hackernews_mcp"]
    },
    "memory": {
      "command": "python",
      "args": ["-m", "agent_memory_mcp"]
    }
  }
}

Why Self-Host MCP Servers?

Zero API costs — Most servers work without external API keys
Full privacy — Your data stays on your infrastructure
Customizable — Modify and extend any server to fit your needs
No vendor lock-in — Switch clients without rewriting integrations

Stay Updated

Bookmark the MCP Directory to discover new servers as they're added. New servers ship weekly.

Pro tip: Combine multiple servers in your MCP config. Pair the Cost Tracker with Memory and Wikipedia to build agents that remember facts, track their spending, and research anything — all in one session.

Curated with ❤️ by the AgentPay team. Building the financial infrastructure for autonomous AI agents.

Want your MCP server listed? Open a PR at github.com/Rumblingb/mcp-directory

Why Every AI Agent Needs Persistent Memory: Introducing Agent Memory MCP

Rumblingb — Wed, 13 May 2026 06:29:27 +0000

The Memory Problem in AI Agents

Modern LLMs are incredibly powerful, but they have a fundamental limitation: they forget everything between conversations. Every time you start a new session with an AI agent, it's like talking to someone with amnesia.

This means:

Chatbots can't remember user preferences
Research assistants lose their context mid-project
Autonomous agents restart their reasoning from scratch
Long-running tasks get progressively more expensive as you re-inject context

The solution? Persistent, searchable memory that lives outside the LLM's context window.

Introducing Agent Memory MCP

Agent Memory MCP is an open-source MCP server that provides persistent key-value memory for AI agents. It's like giving your agent its own brain — one that remembers everything without blowing up your token budget.

Core Features

Persistent key-value storage — Store any data with string keys
TTL-based expiry — Set items to auto-expire after a configurable time
Full-text search — Find memories by content, not just by key
Namespace isolation — Separate memories by agent, user, or session
Zero dependencies — Lightweight, runs anywhere Python runs
MCP-native — Works with any MCP-compatible client out of the box

Why Memory Changes Everything

Before Persistent Memory

User: "I prefer responses in Spanish."
Agent: "Okay, noted." [responds in Spanish]
--- Next conversation ---
User: "Tell me about quantum computing."
Agent: [responds in English] ❌ Forgot the preference

After Agent Memory MCP

User: "I prefer responses in Spanish."
Agent: "Okay, noted." 
  → Stores: memory["language_preference"] = "Spanish"

--- Next conversation ---
Agent on startup:
  → Retrieves: memory["language_preference"] = "Spanish"
  → Applies preference automatically ✅

Quick Start

# Clone the repo
git clone https://github.com/Rumblingb/agent-memory-mcp.git
cd agent-memory-mcp

# Install
pip install -r requirements.txt

# Run
python server.py

Add it to your MCP client config:

{
  "mcpServers": {
    "agent-memory": {
      "command": "python",
      "args": ["-m", "agent_memory_mcp"]
    }
  }
}

Using Memory in Your Agent

# Store a memory
await session.call_tool("store_memory", {
    "key": "user_123_preferences",
    "value": {"language": "Spanish", "tone": "professional", "timezone": "UTC-5"},
    "ttl": 604800  # Auto-expire after 7 days
})

# Search memories
results = await session.call_tool("search_memories", {
    "query": "Spanish language preference",
    "limit": 5
})

# Get a specific memory
prefs = await session.call_tool("get_memory", {
    "key": "user_123_preferences"
})

# List all recent memories
recent = await session.call_tool("list_memories", {
    "namespace": "user_123",
    "limit": 20
})

Real-World Applications

1. Customer Support Bots

Remember customer history, past issues, preferences, and resolved tickets. Each conversation picks up where the last one left off.

2. Research Assistants

Store research findings, article summaries, and source links as the agent works through a project. No more losing context after API limits.

3. Personal AI Assistants

Learn user preferences over time — communication style, frequently used tools, common workflows. The agent gets smarter the more you use it.

4. Multi-Agent Systems

Shared memory across agents means Agent A can store findings that Agent B can discover and build upon. True collaborative intelligence.

Memory Management Best Practices

Use TTLs wisely. Set short TTLs (hours) for session data, medium TTLs (days) for user preferences, and long TTLs (months) for learned knowledge.

Namespace by entity. Use namespaces like user:{id}, session:{id}, or project:{name} to keep memories organized and prevent collisions.

Search, don't iterate. When you need information, use search_memories instead of listing everything. It's faster and cheaper.

Clean up expired data. The TTL system automatically deletes expired entries, but you can manually trigger cleanup with cleanup_expired.

Pro Features

The open-source version handles unlimited storage locally. The Pro version ($19/month) adds:

Cloud sync across agents
Advanced semantic search
Priority support
Custom retention policies

👉 Subscribe to Agent Memory MCP Pro — $19/month

Get Started

Agent Memory MCP is free and open-source. Give your agents the gift of remembering.

🔗 GitHub: https://github.com/Rumblingb/agent-memory-mcp

💳 Agent Memory MCP Pro: https://buy.stripe.com/cNifZj0qXesc6DKcfh1oI0y

Built with ❤️ by the AgentPay team. Memory isn't just storage — it's identity.

Build AI Agents That Pay Their Own Way: The Agent Cost Tracker MCP Server

Rumblingb — Wed, 13 May 2026 06:29:06 +0000

The Problem: AI Agents Are Expensive and Opaque

Every time you spin up an AI agent — whether it's a coding assistant, a customer support bot, or a data pipeline processor — you're burning through API credits, compute time, and token budgets. The problem is that most agents have zero visibility into their own costs.

You deploy them, they run, and at the end of the month you get a surprise bill. Wouldn't it be better if your agents could track their own spending in real-time, enforce budgets, and even generate revenue?

Enter the Agent Cost Tracker MCP Server

The Agent Cost Tracker MCP is an open-source MCP (Model Context Protocol) server that gives your AI agents real-time cost awareness. It integrates directly with Stripe to provide:

Real-time cost tracking — Every LLM call, API request, and compute operation is logged with its cost
Per-agent budgets — Set monthly or per-task spending limits
Usage analytics — See exactly where your money is going
Stripe billing integration — Bill clients, track revenue, and monetize your agents
Alert thresholds — Get notified when costs exceed configurable limits

How It Works

The server implements the MCP protocol, meaning any MCP-compatible client (Claude Desktop, Cline, Cursor, custom agents) can connect to it and start tracking costs immediately.

# Example: Connecting your agent to the cost tracker
from mcp import ClientSession

async with ClientSession(transport) as session:
    # Track a model call
    cost = await session.call_tool("track_cost", {
        "agent_id": "code-reviewer-1",
        "model": "gpt-4o",
        "input_tokens": 1500,
        "output_tokens": 420,
        "cost_per_million_input": 2.50,
        "cost_per_million_output": 10.00
    })
    print(f"This call cost: ${cost:.4f}")

    # Get current month's spending
    report = await session.call_tool("get_spending_report", {
        "agent_id": "code-reviewer-1",
        "period": "month"
    })
    print(f"Monthly spend: ${report['total']:.2f}")

Real-World Use Cases

1. Client-Facing Agent Billing

Run agents for clients and bill them accurately. The Stripe integration creates invoices automatically based on actual usage. No more estimating — every token is tracked.

2. Internal Cost Allocation

Different departments or projects get charged for the agents they use. Set hard caps so one team can't blow the entire budget.

3. Agent Marketplace

Build agents that are self-sustaining — they pay for their own API costs by generating value (or direct revenue through Stripe checkout).

Setting Up Your Own Cost Tracker

Getting started takes about 5 minutes:

# Clone the repo
git clone https://github.com/Rumblingb/agent-cost-tracker-mcp.git
cd agent-cost-tracker-mcp

# Install dependencies
pip install -r requirements.txt

# Configure your Stripe keys
cp .env.example .env
# Add your STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET

# Start the server
python server.py

Then configure your MCP client to connect to it. You'll immediately have full visibility into every cost your agents generate.

Monetization: Let Your Agents Pay Their Way

The most exciting feature is the Stripe integration. You can:

Create subscription plans for your agent services
Generate payment links for one-time usage
Automatically invoice recurring agent usage
Track revenue alongside costs for true P&L per agent

👉 Subscribe to Agent Cost Tracker Pro — $19/month

Architecture Overview

┌──────────────┐     ┌──────────────────────┐     ┌───────────┐
│  MCP Client  │────▶│  Cost Tracker MCP    │────▶│  Stripe   │
│  (Your Agent)│     │  (Python Server)     │     │  API      │
└──────────────┘     └──────────────────────┘     └───────────┘
                           │
                     ┌─────▼──────┐
                     │  SQLite    │
                     │  (Cost DB) │
                     └────────────┘

The server stores all cost data locally in SQLite (or PostgreSQL for production), and syncs billing events to Stripe.

Get Started Today

The Agent Cost Tracker MCP is free and open-source. Star it on GitHub, contribute, and start building agents that understand the value of every API call they make.

🔗 GitHub: https://github.com/Rumblingb/agent-cost-tracker-mcp

💳 Subscribe to Pro ($19/month): https://buy.stripe.com/dRm4gB7Tpck43ry9351oI0x

Built with ❤️ by the AgentPay team. We believe AI agents should be financially autonomous.