Tired of switching apps every time you want to log a task while coding? You can push captures directly into Notestream from Cursor or ChatGPT using the MCP API, without leaving your workflow.
Most developers working with AI tools hit the same friction point: a task surfaces during a Cursor session or a ChatGPT conversation, and the only way to capture it is to stop, open another app, type the thing in, and hope you remember the context. That interruption breaks flow. The Notestream MCP API removes it.
What the MCP API Does
The MCP API is Notestream's third capture surface, alongside the web assistant field and forwarded email. It accepts a POST request with a content string (ideas, commitments, or deadlines worded exactly as you think them), routes it through the same per-capture classifier that handles every other capture, and returns a classified task, reference note, or reminder.
The capture goes into your queue immediately. By the time you finish your coding session and open Notestream, everything you sent during the session is already classified and ready to dispatch.
You don't need to pre-sort, tag, or categorize anything. Send the raw thought. The classifier handles the rest. This is what "classification on arrival" looks like in practice: you capture the idea in context, the system does the organizing work, and your queue stays clean without manual overhead.
Setting Up the MCP Connection in Cursor
Cursor supports MCP servers in its settings. You add Notestream as an MCP endpoint, and Cursor can then call the API on your behalf during an agentic session.
Here's what the configuration looks like in your Cursor MCP settings:
{
"notestream": {
"url": "https://vuakkixyfmtrrfrsdysn.supabase.co/functions/v1/mcp-proxy",
"headers": {
"x-mcp-secret": "YOUR_MCP_SECRET",
"x-user-id": "YOUR_USER_ID"
}
}
}Once the connection is active, Claude inside Cursor can call the Notestream MCP directly. You can prompt it: "Log this as a task in Notestream: refactor the auth middleware to use the new token schema." Cursor sends the capture to your queue. You never leave the editor.
The practical effect: every implementation note, bug you spot mid-session, or follow-up task you think of while reading code can go into Notestream in one step. No app switching, no context collapse. The task lands in your queue with the exact wording you used in the moment, before the context fades.
Calling the API from ChatGPT
ChatGPT's custom actions let you connect any REST endpoint directly to a GPT. Once you configure the Notestream API as a custom action, you can tell ChatGPT to log a capture at any point in the conversation.
The OpenAPI schema for the capture action is straightforward:
{
"openapi": "3.1.0",
"info": { "title": "Notestream Capture", "version": "1.0" },
"servers": [{ "url": "https://vuakkixyfmtrrfrsdysn.supabase.co/functions/v1" }],
"paths": {
"/mcp-proxy": {
"post": {
"operationId": "createCapture",
"requestBody": {
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"action": { "type": "string", "enum": ["create_task"] },
"content": { "type": "string" },
"user_id": { "type": "string" }
}
}
}
}
}
}
}
}
}After setup, you can end any ChatGPT session with: "Send this as a task to Notestream: [summary of what to do next]." The capture lands in your queue, classified on arrival, ready to dispatch when you open the app.
This is the loop that makes Notestream useful across your full AI stack. ChatGPT, Claude, Gemini, Cursor: each conversation or session can push captured work into one queue that you act on, instead of losing it to chat history.
What Gets Classified on Arrival
Once a capture arrives via the MCP API, the same classification logic runs as it does for any other capture. The AI reads the content and places it as one of four types: task, reference note, sub-task, or reminder.
A capture like "refactor auth middleware to new token schema" comes back as a task. "Notes on the new rate limiting approach: use per-user buckets, not global" comes back as a reference note. "Follow up with the API docs team by Friday" comes back as a reminder.
You see the classified result the next time you open your Notestream queue. The classification happened when you sent it, not when you reviewed it. That's what "on arrival" means in practice: no batch-processing step, no triaging session at the end of the day. Every capture is already sorted before you need it.
The distinction matters for how you work. If classification happened later, you'd need to revisit every item you logged and decide what it was. That's overhead. When it happens on arrival, you open the queue and see organized, actionable items. The reviewing step becomes the routing step, not a sorting step.
Capture Ideas From Anywhere in Your AI Stack
The three capture surfaces in Notestream work differently, and the MCP API fills a specific gap. The web assistant field is for intentional captures: you open Notestream and type a thought directly. Forwarded email is for capturing commitments and ideas that arrive in your inbox. The MCP API is for captures that happen in the middle of another AI session.
Those in-session captures are easy to lose. You're deep in a Cursor session, Claude surfaces a related issue, you make a mental note, and then you're back in the code. The thought evaporates by the time you're done. The MCP API makes in-session capture as easy as saying something to the AI you're already talking to.
The same pattern applies to ChatGPT or Gemini sessions. You're working through a strategy question, realize you need to follow up on something, and instead of tabbing away to write it down, you just tell ChatGPT: "Add to Notestream: research competitor pricing for the Q3 deck." Done. Back to the conversation.
Over time, this habit changes the shape of your AI workflow. Instead of sessions that end with a pile of scattered browser tabs, notes app entries, and things you meant to do later, you end sessions with a clean, classified queue.
From Cursor to Dispatch in One Flow
Here's what a typical AI-assisted development session looks like with the MCP API connected:
You're in Cursor, working on the settings screen. Claude spots a related bug in the email validation logic. You prompt: "Log this as a task in Notestream: fix email validation to reject addresses without a TLD." Cursor calls Notestream. The task is queued and classified.
Twenty minutes later, you finish the current feature. You open Notestream, find the email validation task in the queue, and dispatch it to Claude Code with full context intact. Claude Code reads your codebase and handles the fix.
The MCP API closed the gap between "I noticed something" and "I acted on it." The capture happened in context. The dispatch happened when you were ready. Nothing got lost in chat history or a sticky note that never went anywhere.
This is what a central hub for AI workflow means in practice. You capture ideas from anywhere in your AI stack. Notestream collects what your sessions generate, classifies it on arrival, and holds it until you're ready to move. The dispatch hub then routes each task to the right AI: in-app chat for writing and reasoning, Claude Code for implementation, Claude Cowork for automations, or Lovable for design work.
The MCP API is what makes that loop complete. Without it, tasks that surface during coding sessions or AI conversations either get lost or require an interruption to capture. With it, every session feeds your queue automatically. Your stack stays connected, and nothing falls through the gap between tools.
Try it free at notestream.ai.