DEV Community

Yash Sonawane
Yash Sonawane

Posted on

NotionOps AI — I Built an AI DevOps Brain That Lives Inside Notion 🧠

#notionchallenge #devchallenge #mcp #ai

Notion MCP Challenge Submission 🧠

The Problem Every Developer Knows But Nobody Talks About

It's 11pm. A critical bug hits production.

You open GitHub to check the commit. Then Jira to find the ticket. Then Slack to see who's on-call. Then Notion to check if there's a runbook. Then back to GitHub. Then your terminal.

Five tools. Zero single source of truth.

This is the hidden tax on every engineering team — the context switching, the scattered data, the manual standup updates nobody remembers to write. I built NotionOps AI to kill that tax entirely.

Notion becomes your team's central nervous system. AI does the rest.

What Is NotionOps AI?

NotionOps AI is an MCP server that connects GitHub events to Notion using Claude as the intelligence layer. Every push, pull request, and issue automatically flows into a structured Notion workspace — analyzed, categorized, prioritized, and ready to act on.

No manual task creation. No forgotten incidents. No missed standups.

"Your GitHub history and your Notion workspace, finally speaking the same language."

Live Demo Flow

  1. Developer pushes: hotfix: null pointer in payment gateway
  2. GitHub webhook fires → NotionOps AI receives it
  3. Claude analyzes the commit → detects CRITICAL severity (payment + production keyword)
  4. A P0 incident page appears in Notion — automatically
  5. A task is created: "Fix payment gateway null pointer" → Priority: High → Status: To Do
  6. At 9am, the AI standup runs: "3 commits yesterday, 1 P0 incident resolved, 2 tasks in progress"

The entire team is informed. Nobody typed a thing.

The Architecture 

GitHub Webhook
      │
      ▼
FastAPI Server  ←──────────────────────────────┐
      │                                         │
      ▼                                         │
AI Analysis (Claude)                            │
   • Classify commit type                       │
   • Score severity (CRITICAL/HIGH/NORMAL)      │
   • Extract task details                       │
   • Generate PR risk assessment                │
      │                                         │
      ▼                                         │
MCP Server ─────────────────────► Notion API   │
   10 tools exposed:                            │
   • analyze_commit                             │
   • analyze_pr                                 │
   • create_task                                │
   • log_incident                               │
   • log_deployment                             │
   • generate_standup                           │
   • query_project  ──────────────────────────►┘
Enter fullscreen mode Exit fullscreen mode

The MCP server is the brain. Claude Desktop, the webhook server — these are just clients calling its tools.

How I Used Notion MCP

Notion MCP is the backbone of this entire project, not an afterthought.

Every piece of intelligence NotionOps AI produces ends up structured inside Notion through four purpose-built databases:

1. Tasks Database

Auto-populated from GitHub events. Every commit, PR, and issue becomes a trackable task with AI-assigned priority, category, and summary. No developer touches this manually.

Properties: Name, Priority (High/Medium/Low), Category (Bug/Feature/Chore/Deploy), Status (To Do/In Progress/Done/Blocked), Source, Created date

2. Deployments Database

Every deployment event gets logged with version, environment, commit SHA, and status. Teams get a full audit trail of what shipped, when, and whether it succeeded — automatically.

3. Incidents Database

When Claude detects CRITICAL or HIGH severity keywords — payment, auth, crash, hotfix, null pointer — it creates a P0/P1 incident page instantly, with description, severity label, assignee field, and an investigation notes section ready to fill.

4. AI Digest Database

Every morning, the standup generator reads all open tasks from Notion, feeds them to Claude, and writes a structured daily report back into Notion. The team gets their standup whether or not anyone remembered to write it.

The 10 MCP Tools

The MCP server exposes these tools to any MCP client (Claude Desktop, custom agents, etc.):

Tool What It Does
analyze_commit AI-classify commit → type, priority, severity score
analyze_pr AI-summarize PR → risk level, review checklist, complexity
analyze_issue AI-classify GitHub issue → task details
create_task Write structured task to Notion Tasks DB
log_deployment Record deployment event to Notion Deployments DB
log_incident Create P0/P1 incident page with full details
update_task_status Change task status by Notion page ID
get_open_tasks Fetch all active tasks from Notion
generate_standup AI standup from Notion data, saved back to Digest DB
query_project Natural language Q&A over live Notion data
process_github_push Full pipeline: analyze → task → incident (if critical)

The killer tool is process_github_push. One call handles the full pipeline — AI analysis, Notion task creation, and automatic incident escalation if the commit is critical. This is what makes the live demo so clean.

The AI Intelligence Layer

The analysis engine uses Claude to turn raw commit messages into structured intelligence. Here's the actual severity scoring logic:

CRITICAL — keywords: hotfix, critical, urgent, payment, auth, security, crash, null pointer, production

HIGH — keywords: bug fix, error, failure, broken, regression

NORMAL — everything else

This means a commit like fix: update button color creates a Low priority Chore task quietly. A commit like hotfix: payment gateway crash on null user triggers a P0 incident page, a High priority Bug task, and shows up red in the standup.

The AI is context-aware, not just keyword-matching. Claude understands that "add caching to product API" is a Feature with Medium priority, while "revert: authentication module broken in prod" is a Bug with High severity — without any hardcoded rules.

The query_project Tool — My Favorite Feature

This one makes the demo magical.

After connecting NotionOps AI to Claude Desktop, I can type:

"What are our highest priority tasks right now?"

Claude calls get_open_tasks → reads live Notion data → answers in plain English:

"You have 3 High priority tasks: Fix payment gateway null pointer (In Progress), Update auth token validation (To Do), and Database connection pooling (Blocked). The payment gateway issue has been in progress since yesterday."

No dashboard hunting. No filter clicks. Just ask and get an answer backed by real data.

What I Learned Building This

MCP architecture forces good design. When you're exposing tools to an AI agent, each tool must be small, single-purpose, and well-typed. This discipline made the codebase cleaner than most projects I've shipped.

Background tasks matter more than you think. The webhook server returns 200 OK instantly and processes events asynchronously. Without this, GitHub's webhook delivery would time out on slow Claude API calls.

Notion's API is surprisingly developer-friendly. The properties system — especially select, relation, and rollup types — maps naturally to a DevOps data model. The four-database schema I designed (Tasks, Deployments, Incidents, Digest) covers 90% of what an engineering team actually needs to track.

Local simulation is the fastest development loop. I built test_simulate.py on Day 1 — a script that fires fake GitHub payloads at the local server. This meant zero time wasted on ngrok tunnels or real webhook setup during development.

Tech Stack

  • Python — core language
  • MCP SDK — server framework for exposing tools
  • FastAPI — webhook receiver, async background tasks
  • Anthropic Claude API — AI analysis engine
  • Notion API (via MCP) — project brain and output layer
  • Pydantic — schema validation for all GitHub event models

The Repository

Everything is open source.

GitHub: https://github.com/yashsonawane25/NotionOps-AI

The repo includes:

  • Full MCP server with all 10 tools
  • FastAPI webhook server with GitHub signature verification
  • AI analysis engine (commit, PR, issue classification)
  • Notion CRUD layer (tasks, deployments, incidents, digest)
  • Local test simulator — run the full demo without GitHub
  • Claude Desktop config for instant MCP integration
  • README with complete Notion DB setup guide

Running It Yourself 

git clone https://github.com/yashsonawane25/NotionOps-AI
cd NotionOps-AI
pip install -r requirements.txt
cp .env.example .env
# Add your ANTHROPIC_API_KEY, NOTION_TOKEN, and 4 DB IDs

# Start webhook server
uvicorn webhook_server:app --reload --port 8000

# Test the full pipeline locally
python test_simulate.py
Enter fullscreen mode Exit fullscreen mode

The test simulator fires a CRITICAL hotfix commit, a PR, and an issue. Watch three Notion pages appear in real time. That's the whole pitch.

What's Next

NotionOps AI is a foundation, not a finished product. The logical next features:

  • Bidirectional sync — update task status in Notion → post comment back to GitHub PR
  • Velocity anomaly detection — zero commits by 3pm triggers an AI check-in prompt
  • Weekly executive summary — every Monday, Claude reads 7 days of Notion data and writes a leadership digest
  • On-call rotation integration — P0 incidents auto-assign based on a Notion rotation schedule

The architecture supports all of these without major changes. MCP tools compose.

Final Thought

The Notion MCP challenge asked for the most impressive workflow using Notion MCP.

I didn't want to build a demo. I wanted to build the tool I'd actually use on a real project.

NotionOps AI is that tool. GitHub events, AI analysis, Notion as the command center — all wired together in a system that runs without anyone remembering to update it.

The best DevOps tool is the one that works when you're not watching.

Built by Yash Sonawane — B.Tech EE, GH Raisoni College of Engineering & Management, Pune
GitHub: @yashsonawane25

Tags: notion mcp devops ai python hackathon automation github claude

Top comments (0)