DEV Community: member_26847952

Stop Writing API Docs by Hand — Let Notion MCP Do It

member_26847952 — Fri, 27 Mar 2026 17:50:57 +0000

This is a submission for the Notion MCP Challenge

What I Built

APIVault — a local FastAPI app that turns raw route code or plain-English API descriptions into full API documentation, then stores everything in Notion through the Notion MCP.

The idea is simple: you point APIVault at a router file (or just describe an endpoint in plain English), and it generates structured documentation and pushes it directly into a Notion workspace it sets up for you — no copy-pasting, no manual page creation.

The frontend is a vanilla HTML/CSS/JS dashboard with:

Live search across your documented endpoints
Documentation preview pane
Source vs. generated toggle so you can diff your raw code against what was documented

There's also a CLI tool (vault.py) for batch-documenting entire files without opening the UI.

Endpoints

Route	What it does
`POST /api/setup`	Creates (or reuses) the APIVault Notion workspace — an `📖 API Reference` database, a `🏷️ Services` database, and an `📚 API Docs` hub page
`POST /api/document-endpoint`	Documents a single endpoint, writes it to Notion, returns the generated content + the Notion page URL
`POST /api/document-collection`	Splits a router/controller file into individual endpoints and documents them in parallel
`POST /api/generate-readme`	Generates a `📄 [Service] — README` Notion page from endpoints already stored
`GET /api/search?q=`	Powers the dashboard's live search
`GET /api/sidebar`	Feeds the left-side navigation tree

Stack

Backend: FastAPI + Python
AI: HuggingFace Inference API (documentation generation)
MCP: Notion MCP via https://mcp.notion.com/sse (SSE transport)
Frontend: Vanilla HTML/CSS/JS

Video Demo

No video for this submission.

Show us the code

🔗 github.com/himanshu748/dev-challenge-5

Getting started locally

# 1. Clone and set up
git clone https://github.com/himanshu748/dev-challenge-5
cd dev-challenge-5
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt

# 2. Configure environment
cp .env.example .env
# Set NOTION_TOKEN (MCP OAuth token) and HF_TOKEN

# 3. Run
uvicorn app.main:app --reload
# Open http://127.0.0.1:8000

CLI usage for bulk documentation:

python vault.py \
  --file routes/users.py \
  --service UserService \
  --base-url https://api.example.com

How I Used Notion MCP

APIVault uses the Notion MCP exclusively — there are zero calls to the direct Notion REST API anywhere in the codebase. NOTION_TOKEN must be a Notion MCP OAuth access token, not a Notion integration secret. This matches how the hosted MCP is meant to be used: access is granted through the MCP OAuth flow, not the legacy secret model.

On startup, POST /api/setup calls the Notion MCP to provision the entire workspace structure:

An 📖 API Reference database where each endpoint lives as a page with properties like method, path, service, parameters, and response schema
A 🏷️ Services database for grouping endpoints by service name
An 📚 API Docs hub page that ties everything together

When an endpoint is documented (either individually or from a batch file), the generated content is written to a new Notion page via the MCP and the returned Notion URL is surfaced in the dashboard so you can jump straight to it.

The generate-readme flow goes the other way: it queries Notion through the MCP to pull all endpoints for a given service, then synthesizes them into a formatted README page — so Notion stays the source of truth for the whole workflow.

A local JSON cache (data/apivault_state.json) exists purely for UI responsiveness (fast sidebar loads, instant search), but every write and authoritative read goes through the MCP.

What the Notion MCP unlocks here that wouldn't be practical otherwise:

Structured storage without schema management — Notion databases give you typed properties (selects, rich text, URLs) without standing up a real database
Human-readable side effect — every documented endpoint is immediately browsable in Notion by the whole team, not just queryable via API
README generation from live data — because the MCP lets you query what's already stored, the README reflects the actual current state of your docs, not a stale snapshot

Your Team's Code Reviews Are Disappearing — I Built PRReviewIQ to Fix That

member_26847952 — Fri, 27 Mar 2026 17:36:51 +0000

Every code review your team does contains hard-won knowledge: a bug pattern caught, a performance trap avoided, a naming convention enforced. And almost all of it evaporates the moment the PR is merged.

PRReviewIQ is my attempt to fix that. It's an AI code review tool that doesn't just comment on diffs — it remembers. Every insight gets logged into a living Notion knowledge base via Notion MCP, so your team's collective code quality wisdom compounds instead of getting buried in closed PRs.

Video Demo

Show Us the Code

🔗 github.com/himanshu748/dev-challenge-4

The Problem Worth Solving

Code review is one of the highest-leverage activities on any engineering team — but it's almost entirely ephemeral. Comments live on GitHub. Patterns go untracked. New teammates repeat the same mistakes. There's no institutional memory.

I wanted Notion to be that memory. Not as a place to manually paste notes, but as a database that an AI agent actively writes to as part of the review process itself.

How It Works

PRReviewIQ ships as two interfaces over the same core:

Web app — a FastAPI server at http://127.0.0.1:8000 where you can paste diffs and trigger reviews through a browser UI.

CLI — run it directly against a local git repo:

python review.py --repo /path/to/repo

# Or target a single file for pre-commit checks
python review.py --file path/to/file.py --pr-title "Pre-commit review" --repo-name my-repo

Under the hood, every review goes through HuggingFace, and every finding gets written into Notion through MCP.

How I Used Notion MCP

Here's the part I'm most proud of from an architecture standpoint.

Most Notion integrations make direct REST calls. I went a different route: PRReviewIQ runs the official @notionhq/notion-mcp-server locally via npx, and passes NOTION_TOKEN directly to the MCP process. The app itself never touches the Notion REST API — all writes happen through MCP.

This matters because it means the LLM is using Notion as a tool, not just a destination. When it reviews a diff, it decides what's worth logging, how to categorize it, and where it belongs in the knowledge base — the same way a human reviewer would decide what's worth writing down.

What gets built in Notion:

A coding standards database that evolves as the agent identifies recurring patterns. You can query it live via GET /api/standards — it reads directly from Notion and returns JSON, so the app and the team always share the same source of truth.
A reviews log — every PR review stored as a structured Notion entry, searchable and linkable.
Weekly digest pages — POST /api/weekly-digest aggregates trends across recent reviews and writes a summary page your team can async through on Mondays.

The compounding effect is the real value: the knowledge base gets more useful the more you use it.

Technical Note on the MCP Setup

Running @notionhq/notion-mcp-server via npx means Node.js needs to be installed alongside Python. The MCP server process is spawned by the app at runtime — no separate setup step required beyond having npx available.

# Prerequisites
python 3.11+
node + npx

# .env
HF_API_KEY=hf_...
NOTION_TOKEN=...
NOTION_PARENT_PAGE_ID=...

# Run
pip install -e .
uvicorn app.main:app --reload

The first call to POST /api/setup provisions the full Notion workspace structure — databases, log pages, and the standards section — and you're ready to start reviewing.

What I'd Build Next

The CLI is useful but I want to wire it into a git pre-commit hook so reviews happen automatically before every push. The Notion knowledge base is already there — the next step is making the feedback loop tighter.

From Job Post to Offer Letter — Automated with Notion MCP

member_26847952 — Fri, 27 Mar 2026 16:11:42 +0000

How I Used Notion MCP to Build an AI Recruiting Assistant

What I Built

HireIQ is an AI-powered recruiting assistant that uses Notion as its entire operational backbone. Point it at a role you're hiring for and it will:

Spin up a recruiting workspace in Notion automatically
Write polished, structured job descriptions and save them as Notion pages
Screen candidates against the role criteria and log results
Generate offer letters — drafted by AI, stored in Notion

The entire hiring pipeline lives in Notion. HireIQ just drives it.

Video Demo

Show Us the Code

🔗 github.com/himanshu748/dev-challenge-3

How I Used Notion MCP

HireIQ connects to Notion via the remote Notion MCP server at https://mcp.notion.com/sse — attached directly to a HuggingFace MCPClient. This means the AI model doesn't just answer questions about hiring; it actively reads from and writes to Notion as part of every step in the pipeline.

1. Workspace Setup (`POST /api/setup`)

On first run, HireIQ uses Notion MCP to create the full recruiting workspace structure — databases, pages, and sections — ready to receive jobs and candidates. Zero manual Notion configuration needed.

2. Job Description Creation (`POST /api/add-job`)

The AI generates a complete, professionally formatted job description and writes it directly into Notion via MCP. Every role gets its own page, making the workspace a living hiring hub rather than a static document.

3. Candidate Screening (`POST /api/screen-candidate`)

HireIQ reads the job requirements from Notion, evaluates the candidate against them using the LLM, and logs the screening result back into Notion — keeping everything in one place for the hiring team to review.

4. Offer Letter Generation (`POST /api/generate-offer`)

Once a candidate clears screening, HireIQ drafts a tailored offer letter and saves it to Notion via MCP. The whole candidate journey — from application to offer — is tracked in one workspace.

What Notion MCP Unlocks

The remote MCP connection (https://mcp.notion.com/sse) is what makes this work at a different level than a plain Notion API integration. The LLM has Notion MCP as an attached tool — so it can decide when and how to read or write Notion data as part of reasoning through each task. It's not just API calls wrapped in Python; the model is an active agent that uses Notion as its memory and output layer.

Every write endpoint returns a notion_urls field so the frontend can link directly to the pages the agent just created.

Tech Stack

Layer	Technology
Backend	FastAPI + Python
AI / LLM	HuggingFace (`Qwen/Qwen2.5-72B-Instruct`) via MCPClient
Data store	Notion (via remote Notion MCP at `https://mcp.notion.com/sse`)
Frontend	Vanilla HTML/CSS/JS

Getting Started

# 1. Clone the repo
git clone https://github.com/himanshu748/dev-challenge-3

# 2. Create a virtual environment
python3 -m venv .venv
source .venv/bin/activate

# 3. Install dependencies
pip install -r requirements.txt

# 4. Configure environment variables

Create a .env file:

HF_API_KEY=hf_...
NOTION_TOKEN=...          # Must be a current OAuth access token (not an internal integration token)
NOTION_PARENT_PAGE_ID=... # Parent page for the recruiting workspace
HF_MODEL=...              # Optional — defaults to Qwen/Qwen2.5-72B-Instruct

# 5. Start the server
uvicorn app.main:app --reload

Open http://127.0.0.1:8000 in your browser.

Note: NOTION_TOKEN must be a current OAuth access token for the remote Notion MCP server. A plain internal integration token will not work for the https://mcp.notion.com/sse connection.

How I Used Notion MCP to Build an Autonomous Personal Finance Tracker

member_26847952 — Thu, 26 Mar 2026 16:41:46 +0000

FinanceIQ — AI-Powered Finance Tracker Built with Notion MCP

What I Built

FinanceIQ is an AI-powered personal finance tracker that turns Notion into a fully automated financial command center. It ingests your bank's CSV exports, categorizes every transaction using AI, detects suspicious or anomalous spending, generates monthly financial reports, and fires budget alerts — all written directly into Notion via the Notion MCP.

No spreadsheet juggling. No manual tagging. Your finances, organized and analyzed — living right inside Notion.

Video Demo

Show Us the Code

🔗 github.com/himanshu748/dev-challenge-2

How I Used Notion MCP

Notion MCP is the backbone of FinanceIQ. Rather than building a standalone dashboard that lives in isolation, I wanted all financial data to live natively in Notion — so it's searchable, shareable, and editable like any other Notion page.

Here's exactly how Notion MCP powers each part of the workflow:

1. One-Click Workspace Setup

On first run, FinanceIQ uses Notion MCP to automatically create:

An Expenses database with the right properties (date, amount, category, anomaly flag, etc.)
A Reports page where monthly summaries will be written

No manual Notion setup required — the agent handles it entirely through MCP.

2. Transaction Import & AI Categorization

When a user uploads a CSV (from Chase, Bank of America, Wells Fargo, or Mint), FinanceIQ:

Parses each transaction
Sends it to a HuggingFace-hosted Mistral model (via MCPClient) for categorization into 10 spending categories
Flags anomalies: transactions that are 3x the category average, duplicates, or suspiciously round amounts
Writes each transaction as a new row in the Notion Expenses database via MCP

3. Monthly Report Generation

The /report endpoint aggregates data from Notion, runs it through the AI, and writes a structured monthly report page back into Notion including:

Income vs. expenses summary
Category-by-category breakdown
AI-generated spending recommendations

4. Budget Alerts

Users can set monthly budget limits per category. FinanceIQ compares actuals against limits and — when thresholds are exceeded — creates a dedicated Budget Alert page in Notion via MCP with details on which categories overspent and by how much.

What Notion MCP Unlocks

The key insight: Notion MCP lets an AI agent treat Notion as a live, writable database — not just a document viewer. That means FinanceIQ can autonomously create structure, push data, and generate reports without any manual copy-pasting. The financial intelligence stays inside Notion where users already live and work.

Tech Stack

Layer	Technology
Backend	FastAPI + Python
AI / LLM	HuggingFace (Mistral-Small-3.1-24B) via MCPClient
Data store	Notion (via Notion MCP)
Frontend	Vanilla HTML/CSS/JS — newspaper-inspired design

Getting Started

# 1. Clone the repo
git clone https://github.com/himanshu748/dev-challenge-2

# 2. Install dependencies
pip install -r requirements.txt

# 3. Configure environment variables
cp .env.example .env
# Add your HF_API_KEY and NOTION_TOKEN

# 4. Start the server
uvicorn main:app --reload

Then open http://localhost:8000 in your browser.

Required environment variables:

Variable	Description
`HF_API_KEY`	Your HuggingFace API key
`NOTION_TOKEN`	Your Notion integration token
`NOTION_PARENT_PAGE_ID`	(Optional) Parent page ID for the workspace
`HF_MODEL`	(Optional) Defaults to `mistralai/Mistral-Small-3.1-24B-Instruct-2503`

I Built an AI PM That Creates PRDs & Sprint Plans Directly in Notion

member_26847952 — Thu, 26 Mar 2026 15:44:10 +0000

This is a submission for the Notion MCP Challenge

What I Built

AutoPM is an AI-powered product management assistant that turns a single product idea
into a fully structured Notion workspace — PRDs, task breakdowns, daily standups, and
sprint plans — in seconds.

No more context-switching between AI tools and your Notion workspace. Just describe your
product idea, and AutoPM:

Generates a full PRD — problem statement, goals, user personas, user stories, and out-of-scope items
Breaks it into Epics & Tasks — with priorities, story points, and a ready-to-go Sprint 1 plan (~20 story points)
Writes everything directly to Notion via Notion MCP
Reads your workspace via MCP to generate context-aware daily standups and sprint plans from your real backlog

🔗 Live demo: autopm-two.vercel.app

🔗 GitHub: github.com/himanshu748/dev-challenge-1

Video Demo

Show us the code

himanshu748 / dev-challenge-1

AutoPM — AI Product Manager

AI-powered product management assistant that creates PRDs, task breakdowns, standups, and sprint plans directly in Notion — built with HuggingFace Inference API + Notion MCP.

Built for the dev.to Notion MCP Challenge.

Live demo: autopm-two.vercel.app

What It Does

Enter a product idea and AutoPM:

Generates a full PRD via HuggingFace AI (problem, goals, personas, user stories, scope)
Creates an Epics & Tasks breakdown with priorities and story points
Writes everything to Notion via Notion MCP (stdio transport)
Reads your workspace via MCP to generate context-aware standups and sprint plans

How I Used Notion MCP

AutoPM uses @notionhq/notion-mcp-server via stdio transport for ALL Notion operations:

Reads — API-post-search to scan workspace pages, API-get-block-children to read task data
Writes — API-post-page to create PRD pages, task breakdowns, standup reports, sprint plans
Auth check — API-get-self to verify MCP connectivity on health check

The MCP server…

View on GitHub

How I Used Notion MCP

Notion MCP is the backbone of AutoPM — every single Notion interaction goes through it,
zero direct REST calls.

I spin up @notionhq/notion-mcp-server as a stdio child process per request, managed
by the Python mcp SDK's ClientSession:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async with stdio_client(StdioServerParameters(
    command="npx",
    args=["-y", "@notionhq/notion-mcp-server"],
    env={"NOTION_TOKEN": token},
)) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        await session.call_tool("API-post-page", {...})

MCP tools used

Tool	Purpose
`API-get-self`	Health check — verify MCP connectivity on startup
`API-post-search`	Scan workspace for existing pages before generating standups
`API-get-block-children`	Read task data from Notion for context-aware generation
`API-post-page`	Create PRD pages, task breakdowns, standup reports, sprint plans

What Notion MCP actually unlocks

Without MCP, AutoPM would be a one-way pipe — generate content, dump it somewhere.
With MCP, it becomes bidirectional: it reads your existing workspace state before
generating anything. The standup and sprint planner aren't making things up — they're
grounded in your actual Notion data. That's the real unlock.

Architecture

┌─────────────────┐     ┌──────────────────────┐     ┌──────────────────────┐
│  Browser (UI)   │────▶│  FastAPI Backend      │────▶│  Notion MCP Server   │
│  Vanilla HTML   │     │  (Python)             │     │  (stdio transport)   │
└─────────────────┘     └────────┬─────────────┘     │  npx @notionhq/      │
                                 │                    │  notion-mcp-server   │
                                 ▼                    └──────────┬───────────┘
                        ┌──────────────────┐                    │
                        │  HuggingFace     │                    ▼
                        │  Inference API   │           ┌─────────────────┐
                        │  (Qwen 72B)      │           │  Notion API     │
                        └──────────────────┘           └─────────────────┘

Flow: HuggingFace (Qwen 2.5 72B) generates structured PM content → FastAPI formats
Notion blocks → MCP writes/reads Notion workspace

Tech Stack

Backend: FastAPI (Python)
AI: HuggingFace Inference API — Qwen/Qwen2.5-72B-Instruct (free tier!)
Notion: @notionhq/notion-mcp-server via stdio transport
MCP SDK: Python mcp package — ClientSession + StdioServerParameters
Frontend: Vanilla HTML/CSS/JS, glassmorphism dark theme
Deployed on: Vercel

Just completed AWS AI & ML challenge.

member_26847952 — Mon, 21 Jul 2025 19:21:27 +0000

Hey dev++ community! 🚀

Just completed the AWS AI & ML Scholars Challenge and got certified in Generative AI with AWS!

Learned a ton about AWS Bedrock, SageMaker, prompt engineering, and building real AI applications. The hands-on experience with generative AI was amazing.

Would love to connect with anyone else working on AI/ML projects or interested in AWS AI services!

Check out my full post: (https://www.linkedin.com/posts/himanshu748_aws-artificialintelligence-machinelearning-activity-7353138026996289538-tIXc)

What AI projects are you all working on? Let's share and learn together! 💪

AWS #AI #MachineLearning #DevCommunity[]

Get your startup logo in seconds

member_26847952 — Sat, 05 Jul 2025 18:32:52 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

An imagen powered logo generator for startups.

Demo

https://aistudio.google.com/apps/drive/18tmCeBIzNHseSJjtA4sVC5NHLAFnoAgS?showPreview=true&resourceKey=

My Experience

It was nice working with Google ai studio after 1 and half years it's really upgraded

DEV Community: member_26847952

Stop Writing API Docs by Hand — Let Notion MCP Do It

What I Built

Endpoints

Stack

Video Demo

Show us the code

Getting started locally

How I Used Notion MCP

Your Team's Code Reviews Are Disappearing — I Built PRReviewIQ to Fix That

Video Demo

Show Us the Code

The Problem Worth Solving

How It Works

How I Used Notion MCP

Technical Note on the MCP Setup

What I'd Build Next

From Job Post to Offer Letter — Automated with Notion MCP

How I Used Notion MCP to Build an AI Recruiting Assistant

What I Built

Video Demo

Show Us the Code

How I Used Notion MCP

1. Workspace Setup (POST /api/setup)

2. Job Description Creation (POST /api/add-job)

3. Candidate Screening (POST /api/screen-candidate)

4. Offer Letter Generation (POST /api/generate-offer)

What Notion MCP Unlocks

Tech Stack

Getting Started

How I Used Notion MCP to Build an Autonomous Personal Finance Tracker

FinanceIQ — AI-Powered Finance Tracker Built with Notion MCP

What I Built

Video Demo

Show Us the Code

How I Used Notion MCP

1. One-Click Workspace Setup

2. Transaction Import & AI Categorization

3. Monthly Report Generation

4. Budget Alerts

What Notion MCP Unlocks

Tech Stack

Getting Started

I Built an AI PM That Creates PRDs & Sprint Plans Directly in Notion

What I Built

Video Demo

Show us the code

himanshu748 / dev-challenge-1

AutoPM — AI Product Manager

What It Does

How I Used Notion MCP

How I Used Notion MCP

MCP tools used

What Notion MCP actually unlocks

Architecture

Tech Stack

Just completed AWS AI & ML challenge.

AWS #AI #MachineLearning #DevCommunity[]

Get your startup logo in seconds

What I Built

Demo

My Experience

1. Workspace Setup (`POST /api/setup`)

2. Job Description Creation (`POST /api/add-job`)

3. Candidate Screening (`POST /api/screen-candidate`)

4. Offer Letter Generation (`POST /api/generate-offer`)