Ali Burak Özden

If you've ever wanted to let your AI assistant analyze your PostgreSQL database without worrying about accidental data modifications, you know the struggle. Giving AI access to databases is powerful but risky. One wrong query could mean lost data. This is exactly why I built DB Analyzer MCP.

## The Problem with AI Database Access

Modern AI assistants like Claude are incredibly capable at understanding data patterns, suggesting optimizations, and helping debug complex queries. But there's always been a fundamental tension: **how do you give AI meaningful database access without risking your data?**

Most solutions either give too much access (dangerous) or too little (useless). You end up copying query results back and forth, losing context, and wasting time.

## A Safe Solution: Meet DB Analyzer MCP

DB Analyzer MCP is a Model Context Protocol server that provides **read-only database analysis** for AI assistants. It's designed with security as the top priority while still being genuinely useful.

### Key Features:

- **30 Database Tools** - From schema introspection to performance analysis
- **Read-Only by Design** - Only SELECT, EXPLAIN, SHOW, and WITH queries allowed
- **Multi-Layer Security** - SQL validation, identifier sanitization, query limits
- **Zero Risk** - INSERT, UPDATE, DELETE, DROP are blocked at multiple levels
- **Project-Local Config** - Each project gets its own `.db-mcp/` folder

## What Can It Do?

### Schema Exploration
```
db_tables    → List all tables with row counts and sizes
db_describe  → Complete table info: columns, indexes, FKs
db_erd       → Generate ERD diagrams in Mermaid format
db_grep      → Search schema for keywords instantly
```

### Query & Analytics
```
db_query     → Execute read-only SELECT queries
db_explain   → Run EXPLAIN ANALYZE for optimization
db_analyze   → Column analysis: NULLs, distinct values, min/max
db_stats     → Database statistics overview
```

### Performance Monitoring
```
db_health        → Health check: connections, cache ratio, disk usage
db_slow_queries  → Find slow queries via pg_stat_statements
db_suggest_indexes → Get index recommendations
db_bloat         → Detect table/index bloat
```

### Data Export
```
db_export       → Export to JSON or CSV
db_export_batch → Stream large datasets directly to file
db_report       → Generate comprehensive markdown reports
```

## Quick Start

1. Clone and install:
```bash
git clone https://github.com/ariburaco/db-analyzer-mcp.git
cd db-analyzer-mcp
bun install
```

2. Add to Claude Desktop config:
```json
{
  "mcpServers": {
    "db-analyzer": {
      "command": "bun",
      "args": ["run", "/path/to/db-analyzer-mcp/src/index.ts"]
    }
  }
}
```

3. Initialize in your project:
```
Use db_init with projectPath="/your/project"
Use db_pull to introspect the database
```

That's it. Now Claude can safely analyze your database.

## Security Deep Dive

I built multiple layers of protection:

1. **Statement Whitelist** - Only `SELECT`, `EXPLAIN`, `SHOW`, `WITH` pass
2. **Keyword Blocklist** - Explicit blocking of dangerous keywords
3. **SQL Injection Prevention** - All identifiers validated
4. **Row Limits** - Configurable max rows (default: 10,000)
5. **Query Timeout** - No runaway queries
6. **Pattern Detection** - Blocks file operations, backend termination

Even if someone tries to be clever with SQL injection or obfuscated queries, the multi-layer approach catches it.

## Why I Built This

As developers, we're increasingly relying on AI assistants for database work - understanding schemas, optimizing queries, debugging data issues. But the tooling hasn't caught up. We needed something that's:

- **Actually safe** - Not just "be careful" safe
- **Actually useful** - 30 tools, not just basic SELECT
- **Easy to set up** - Works with Claude Desktop, VS Code, Cursor

DB Analyzer MCP fills that gap.

## Links

- **GitHub**: [https://github.com/ariburaco/db-analyzer-mcp](https://github.com/ariburaco/db-analyzer-mcp)
- **License**: MIT

---

If you find this useful, give it a star on GitHub. PRs and feedback welcome!



If you've ever wanted to let your AI assistant analyze your PostgreSQL database without worrying about accidental data modifications, you know the struggle. Giv...

Introducing DB Analyzer MCP: Safe Database Analysis for AI Assistants

If you’ve ever built a web application using tRPC, you’ve likely encountered the need to cache expensive operations. Whether it’s complex database queries, third-party API calls, or heavy computational tasks, caching is a must-have for efficient and scalable applications. But caching can quickly get complicated—especially when your app grows, and caching needs become more nuanced. This is precisely where our new package, trpc-redis-cache, comes into play.

🚧 The Problem with Manual Caching

Implementing caching manually is often repetitive, error-prone, and can lead to inconsistencies. Manually managing cache keys, invalidations, and handling user-specific caches becomes messy fast. Even a minor mistake can result in stale data, negatively affecting your user experience.

Developers deserve a simple, elegant solution that fits neatly into their existing tRPC ecosystem—without sacrificing flexibility or power.

💡 A Humble Solution: Meet trpc-redis-cache

We built trpc-redis-cache to provide a straightforward yet powerful middleware solution for tRPC procedures. With just a few lines of code, you can integrate Redis caching seamlessly into your tRPC setup. It’s designed to be intuitive, customizable, and reliable.

🔥 Features at a glance:

- Easy Setup: Plug-and-play middleware integration with minimal configuration.
- Flexible Backend: Supports standard Redis instances and serverless solutions like Upstash Redis.
- User-specific and Global Caching: Effortlessly manage caches at a global level or specific to individual users.
- Customizable Keys & TTL: Precisely control cache expiration times and key generation logic.
- Built-in Logging & Debugging: Easily track cache hits, misses, and performance.
- Simple Cache Invalidation: Quickly invalidate cache entries when your underlying data changes.

🚀 Getting Started is Effortless

Installation couldn’t be simpler:

```bash
pnpm add trpc-redis-cache
# or
npm install trpc-redis-cache
# or
yarn add trpc-redis-cache
```

Then add it to your tRPC procedure:

```ts
import { createCacheMiddleware } from 'trpc-redis-cache';

// Create cache middleware with default options
const cacheMiddleware = createCacheMiddleware();

const appRouter = createTRPCRouter({
  getUser: protectedProcedure
    .input(z.object({ id: z.string() }))
    .use(cacheMiddleware)
    .query(async ({ input }) => {
      // This operation will now be cached automatically!
      return await getUserById(input.id);
    }),
});
```

⚙️ Advanced Customization: A Flexible Approach

For more advanced use cases, trpc-redis-cache empowers you with granular control:

- Permanent Global Cache:


```ts
const globalCacheMiddleware = createCacheMiddleware({
  ttl: undefined, // never expires
  useUpstash: true,
  globalCache: true,
  userSpecific: false,
  debug: true,
});
```

- User-Specific Cache with Expiration:


```ts
const userCacheMiddleware = createCacheMiddleware({
  ttl: 3600, // 1 hour
  useUpstash: true,
  userSpecific: true,
  debug: process.env.NODE_ENV === 'development',
});
```


This combination of simplicity and flexibility makes trpc-redis-cache adaptable to virtually any application scenario.

🎉 Why You Should Give it a Try

Caching can significantly improve your application’s performance, reduce latency, and enhance scalability. With trpc-redis-cache, you can do all this effortlessly, without sacrificing developer productivity or code quality. It’s designed with simplicity, clarity, and elegance at its core—enabling you to spend less time worrying about cache management and more time focusing on building great user experiences.

Feel free to explore, contribute, or share your feedback on GitHub!

👉 Explore the package on [GitHub](https://github.com/ariburaco/trpc-redis-cache)

Happy caching! 🚀


If you’ve ever built a web application using tRPC, you’ve likely encountered the need to cache expensive operations. Whether it’s complex database queries, thir...

Featured Post

Introducing DB Analyzer MCP: Safe Database Analysis for AI Assistants

Introducing DB Analyzer MCP: Safe Database Analysis for AI Assistants

Introducing trpc-redis-cache: Simple and Powerful Caching for Your tRPC Procedures

Hot Topics