DEV Community: CorpusIQ

The Largest Hermes Agent Resource Hub — 234+ Tools, Skills, and Guides in One Place

CorpusIQ — Tue, 16 Jun 2026 19:00:40 +0000

After weeks of building with Hermes Agent, we kept running into the same problem: amazing tools, skills, and resources scattered across GitHub, Discord, and community lists with no single place to find them all.

So we built one.

CorpusIQ Hermes Community Hub — the largest organized Hermes knowledge base in existence.

What's Inside

234+ repos across 18 categories — every tool, UI, plugin, and integration
9 role-specific agents — Sales, Marketing, DevOps, Support, Finance, HR, Research, Legal, Executive
18 prompt collections for code generation, content, data analysis, business ops
5 automation blueprints — daily ops, customer lifecycle, content pipeline, financial close, incident response
13 industry case studies — compliance, healthcare, finance, manufacturing, real estate, and more
7 hardware setup guides — Mac Mini to Raspberry Pi to cloud VPS
12 ready-to-deploy cron templates
7 best practice guides — cron design, model selection, memory, security, skill development

Why We Built It

Hermes Agent is incredible. The ecosystem around it is even more incredible. But discovering what exists shouldn't require hunting through 20 different repos and Discord channels.

Every resource is cross-referenced with descriptions, maintainers, star counts, and capabilities. The repo is updated nightly with automated discovery, and there's a community submission form for new resources.

Check it out →

Built by heavy Hermes users, for the community. Not selling anything — just wanted everything in one place.

We Built a Single MCP Endpoint for 36 Business APIs — Here's What We Learned

CorpusIQ — Mon, 08 Jun 2026 18:55:50 +0000

The Problem: API Sprawl Kills AI Agent Productivity

Every AI agent builder hits the same wall. You want your agent to answer a simple business question like "What was our revenue last month?" But the data sits in Stripe. And Quickbooks. And Shopify.

That's three different APIs. Three authentication flows. Three different data models. Scale to 10 tools and you're maintaining a Frankenstein of API integrations that breaks every time one service changes its schema.

Our Solution: One MCP Endpoint, 36 APIs

We built CorpusIQ — a read-only MCP endpoint that normalizes 36 business APIs behind a single connection.

Your AI agent (Claude, Cursor, Hermes, any MCP client) connects once and gets access to:

Payments: Stripe
Accounting: Quickbooks, Xero
E-commerce: Shopify, WooCommerce, Amazon Seller
CRM: HubSpot, Salesforce
Analytics: GA4, Meta Ads, Google Ads
Email: Gmail, Outlook
Database: PostgreSQL, MySQL, MongoDB
And 23 more connectors

Architecture Decisions

1. Read-Only by Design

We never write to your systems. Ever. This was non-negotiable. AI agents make mistakes and we refuse to be the vector for a bad write operation. Every connector is read-only at the API permission level.

2. OAuth 2.0 Device Flow

Traditional OAuth requires a browser callback. AI agents running in terminal or headless environments don't have browsers. We implemented RFC 8628 — the Device Authorization Grant.

Your agent initiates a connection, we return a device code, you verify once via any browser or phone, and the agent gets a persistent refresh token. No passwords exposed. No browser required after first auth.

3. Single Endpoint

Every AI agent framework (Claude Desktop, Cursor, Hermes, Windsurf, Roo Code) uses MCP. We expose one URL:

{
  "mcpServers": {
    "corpusiq": {
      "url": "https://www.corpusiq.io/mcp/direct-connection"
    }
  }
}

One config block. 36 tools. Done.

4. Cross-Source Queries

Queries that span multiple data sources work automatically. Ask "Compare Stripe revenue to Shopify orders for Q1" and the endpoint queries both APIs, normalizes the responses, and returns merged results.

What We Learned

The Hard Part Isn't the APIs

The hard part is normalization. Every API has different field names, date formats, and pagination patterns. Stripe calls it "amount" in cents. Shopify calls it "total_price" in dollars. Quickbooks calls it "TotalAmt" — yes, PascalCase in 2026.

We built a normalization layer that maps every field to a consistent schema. This was 80% of the work.

The MCP Protocol Is Solid

MCP gives agents structured access to tools. Our agents can call tools/list to discover available data sources, then tools/call with natural language parameters. The protocol handles authentication, error propagation, and rate limiting cleanly.

Security Matters from Day One

We have had security researchers poke at the read-only guarantee within hours of launch. Good. We built this with the assumption that every agent is potentially compromised. Scoped OAuth tokens. Audit logging. No write paths anywhere in the codebase.

What's Next

We are adding connectors based on community requests. Current top asks: Notion, Airtable, Linear, and Snowflake.

All documentation is open at github.com/CorpusIQ/corpusiq-docs.

We just launched on Product Hunt — would love your feedback.

What business API would you want connected to your AI agent? Drop a comment.

We Built a Single MCP Endpoint for 36 Business APIs - Here's What We Learned

CorpusIQ — Sun, 07 Jun 2026 03:51:56 +0000

The Problem: API Sprawl Is Killing Operator Productivity

Every business operator we talked to had the same complaint: they spend 40% of their time just logging into different platforms to pull numbers. Stripe for revenue. HubSpot for pipeline. Google Analytics for traffic. QuickBooks for expenses. Slack for team activity. GitHub for engineering velocity.

We counted 36 different APIs that a typical SaaS operator needs to touch weekly. That's 36 different authentication mechanisms, 36 different data formats, 36 different pagination patterns, and 36 different rate limits.

When Anthropic released the Model Context Protocol (MCP) , we saw an opportunity: what if we could collapse all 36 APIs into a single endpoint that any AI agent could query?

What We Built

CorpusIQ is a single MCP endpoint that connects to 36 business APIs. Instead of writing 36 different integration clients, your AI agent talks to one endpoint using one protocol. The agent asks "What's our MRR this month?" and CorpusIQ handles the rest — routing the query to Stripe, normalizing the response, and returning clean, structured data.

Architecture Decisions That Mattered

1. Read-Only by Design

We made the deliberate choice to be read-only. No mutations, no webhooks, no write operations. This wasn't a limitation — it was a strategic decision. Operators need answers, not another tool that can accidentally change production data. Read-only means zero risk of an agent hallucinating a DELETE on your Stripe account.

2. Device Flow OAuth

Every API we connect to requires authentication, and we didn't want to be in the business of storing credentials. We implemented the OAuth 2.0 Device Authorization Grant — the same flow used by Apple TV and streaming devices. Users authorize once through their browser, and we get scoped, revocable tokens. No passwords stored. No shared API keys.

3. Single Endpoint Architecture

Instead of exposing 36 different MCP tools (one per API), we expose a single query tool with a unified schema. The agent doesn't need to know which API to call — it just asks a business question. Our normalization layer handles the routing, query construction, and response formatting.

4. Cross-Source Queries

This is where it gets interesting. "Compare our Google Ads spend with Stripe revenue by week" requires hitting two completely different APIs with different date formats, different aggregation semantics, and different error modes. Our query planner decomposes cross-source queries into parallel sub-queries, then merges and normalizes the results.

What We Learned About API Normalization

Normalizing 36 APIs is humbling. Here's what broke us:

Date formats are a nightmare. ISO 8601, Unix timestamps, "Q1 2026", fiscal calendars. We built a universal date parser that handles 14 different input formats.
Currency normalization requires context. Stripe returns USD as cents. QuickBooks returns it as dollars with 2 decimal places. Google Ads returns micros (millionths of a dollar). Getting this wrong means orders-of-magnitude errors.
Pagination is inconsistent. Some APIs use cursor-based pagination. Others use offset/limit. A few use page numbers. One API we won't name returns everything in a single response unless you pass a specific header — and then it paginates.
Error responses tell different stories. A 429 from Stripe means "back off for 2 seconds." A 429 from HubSpot means "you've hit your daily limit." Same status code, completely different remediation.

Why MCP Was the Right Protocol

We evaluated REST, GraphQL, and gRPC before settling on MCP. Here's why MCP won:

Tool semantics match operator queries. MCP's tool concept maps cleanly to "give me data from Stripe" or "show me HubSpot pipeline."
Streaming by default. Operators want answers fast. MCP's streaming responses mean partial results appear as they arrive.
Structured output guarantees. Unlike REST where you parse whatever the server sends, MCP tools return typed, validated responses.
Transport flexibility. MCP runs over stdio or HTTP. We chose HTTP for cloud deployment, but the stdio option means operators can run CorpusIQ locally.

What's Next

Natural language query layer: "How did our Black Friday campaign perform?" → automatic decomposition across Google Ads, Stripe, and Shopify.
Scheduled reports: Daily/weekly digests from all connected sources, delivered to Slack or email.
Custom connector SDK: Operators can build their own connectors for internal APIs using our normalization framework.

The Bottom Line

The API sprawl problem isn't going away — it's getting worse. Every SaaS tool adds another API to the pile. MCP gives us a way to present a unified interface to AI agents, and the read-only, device-flow, single-endpoint architecture we chose has held up well across 36 very different APIs.

If you're building something similar, our biggest advice: invest in your normalization layer early. The protocol decisions matter less than you think. The data normalization decisions matter more than you think.

CorpusIQ — One MCP endpoint for 36 business APIs. Connect your tools once, ask questions in plain English, get answers from everywhere.

How I Connected 29 Business Data Sources to My AI Agent Through One MCP Endpoint

CorpusIQ — Sat, 06 Jun 2026 16:18:13 +0000

I spent months building individual API integrations for my AI agent. Stripe API for revenue. Shopify API for orders. Quickbooks for financials. HubSpot for CRM. Then I'd have to maintain all of them.

The turning point was discovering MCP (Model Context Protocol).

Instead of 29 separate API integrations, I built one MCP endpoint that connects to everything. My Claude Code setup went from "generate plausible SQL" to actually answering "what's our MRR?" and "which customers haven't renewed?" from live data.

Here's what changed:

Before MCP: My agent could write code and generate text. But it had zero access to real business data. Every "business question" required me to export CSVs, write SQL, or context-switch between tools.

After MCP: One endpoint. 29 data sources. The agent queries Stripe, Shopify, Quickbooks, HubSpot, PostgreSQL, and 24 others through a single connection. No more "let me look that up." It just knows.

The surprising part: the model wasn't the bottleneck. The plumbing was.

If you're building AI agents that need to work with real business data, stop building individual integrations. The MCP approach is simpler, cheaper, and actually works.

Open source at corpusiq.io — includes the MCP endpoint template and setup guide.

Tags: #mcp #ai #devops #api