Tana MCP. Turn unstructured text into structured knowledge graphs.
Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Tana MCP Server turns raw text conversations into structured knowledge graphs. Your AI agent writes complex data—like defining new content types (Supertags), building multi-level outlines, or linking specific ideas to existing records—directly into your Tana workspace using precise commands.
What your AI agents can do
Add checkbox task
Creates a simple to-do item in the Tana inbox that users can check off later.
Add date node
Adds a node specifically formatted for dates (YYYY-MM-DD) directly into your Tana inbox.
Add node
Creates a basic new text node in any specific location like the Inbox or Library.
Define new Supertags and apply them to nodes, ensuring every piece of captured information follows a strict organizational schema.
Create parent nodes that contain multiple child nodes programmatically, forming complex, nested conceptual maps.
Automatically convert meeting notes into functional components like checkable tasks (add_checkbox_task) or specific date markers (add_date_node).
Create explicit references between nodes, ensuring that all linked concepts are traceable back to their source.
Instantly bookmark URLs or create basic text nodes in specific locations like your main Inbox or Library.
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
Tana MCP Server: 10 Tools for Knowledge Graph Operations
These tools let your agent treat your notes like a structured database. Use them to build outlines, manage tasks, and classify every piece of data you capture.
019d7610add checkbox task
Creates a simple to-do item in the Tana inbox that users can check off later.
019d7610add date node
Adds a node specifically formatted for dates (YYYY-MM-DD) directly into your Tana inbox.
019d7610add node
Creates a basic new text node in any specific location like the Inbox or Library.
019d7610add node reference
Creates a link to an existing note, connecting it without copying its content.
019d7610add node with children
Builds a parent node and automatically creates several blank child nodes underneath it in one go.
019d7610add node with fields
Creates an advanced, supertagged note that populates specific structured fields using JSON data.
019d7610add tagged node
Creates a new node and immediately applies a designated Supertag (e.g., #meeting) to it.
019d7610add to inbox
Quickly drops a brand-new, unclassified node directly into the Tana Inbox for later sorting.
019d7610add url bookmark
Creates a dedicated note type that stores and links to an external web address.
019d7610define supertag
Establishes a new, official classification schema (Supertag) within your Tana workspace.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Tana, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Listen up: The Tana MCP Server lets your AI agent treat your notes like a living database, not just some pile of text you copy-pasted from Reddit. It takes raw conversations and turns them straight into structured knowledge graphs that actually work for you.
You're done with copy-pasting; you prompt for structure. Your agent doesn't just summarize what you said—it builds the framework around it. You can make your AI client define entire classification schemas (Supertags) using define_supertag, making sure every thought you capture fits a strict organizational mold. When you write something down, your agent uses that schema to build out complex records; for instance, it'll run add_node_with_fields when you need an advanced note type populated with specific JSON data fields.
Need to organize your thoughts into a deep outline? The agent handles the nesting. It executes add_node_with_children, which builds a parent node and automatically drops several blank child nodes underneath it, letting you build out complex, nested conceptual maps right away. If you just need a basic idea captured somewhere—like dropping a quick thought into your main Inbox or Library—the agent uses add_node to get that simple text node down fast.
It's not just about making notes; it's about making them actionable. When the meeting wraps up, forget manually assigning tasks and dates. The agent converts raw minutes into functional components: you can use add_checkbox_task for a simple to-do item that lives in your Tana inbox until you check it off.
It handles time markers too; running add_date_node drops a node formatted specifically for the date (YYYY-MM-DD) right where you need it.
Linking ideas together is where this thing really shines. Instead of copy-pasting chunks of text, your agent uses add_node_reference, creating explicit links to existing notes so all concepts are traceable back to their source material. You can also quickly drop an unclassified thought anywhere using add_to_inbox or create a specialized bookmark for external sites with add_url_bookmark.
If you're capturing information that needs a specific label, like designating it as a meeting note, the agent uses add_tagged_node to create the node and slap the designated Supertag right on it.
This system bypasses manual entry entirely. The agent handles all the classification, linking, and structuring work for you. It builds multi-level hierarchies by creating parent nodes, then ensures that every piece of information is properly categorized and linked within your graph, keeping your focus local but making sure nothing gets lost in the shuffle.
How Tana MCP Works
- 1 First, append the generic Tana matrix module into your Vinkius connective logic workspace.
- 2 Next, get an active
TANA_API_TOKEN(requires a Tana Plus/Pro account) and pass it as a secure parameter to your agent. - 3 Finally, prompt your agent naturally: 'Send a structured meeting note for the Q3 review. Tag it with #meeting, include three checklist items, and link it to Project Alpha.' The agent runs all necessary tools automatically.
The bottom line is you tell your AI client what you want in terms of knowledge structure, and Tana handles building the precise node connections and classifications for you.
Who Is Tana MCP For?
This server targets power users who deal with massive amounts of unstructured information—people whose job is generating insights from meetings, research papers, or code reviews. If your workflow involves converting 'stuff I wrote' into a usable system of knowledge, this is for you.
Uses the agent to dispatch asynchronous memos and capture multi-tiered references quickly after meetings, avoiding heavy manual logging.
Solidifies operational ontologies by systematically running define_supertag and verifying schemas for structured data management.
Builds deep graph linkages by tying bookmarks, date blocks, and nested lists together through complex prompt interactions.
What Changes When You Connect
- Build complex outlines: Use
add_node_with_childrento define a project scope with multiple sub-tasks, all in one command. You don't manually link everything up. - Enforce data rules: Run
define_supertagfirst, then useadd_tagged_node. This ensures that every note you capture adheres to your required organizational schema. - Track timelines automatically: Convert meeting dates into proper time markers using
add_date_node, making them searchable and sortable within the graph structure. - Map relationships easily: Instead of copy-pasting chunks of text, use
add_node_referenceto link an idea back to its original source node. The context is always clear. - Capture complex records: For notes that need more than just a title and content,
add_node_with_fieldslets you inject structured data (like JSON) right into the Supertag.
Real-World Use Cases
Turning chaotic meeting minutes into an actionable plan
A Product Manager just finished a brainstorm. They prompt their agent: 'Create a Quarterly Strategy node, tag it #product-plan, and include three main initiatives.' The agent uses add_tagged_node for classification, then runs add_node_with_children to build the outline, and finally executes add_checkbox_task on each child item. Minutes are now a structured plan.
Archiving research findings from web links
A Researcher reads an article and needs to save it with context. They prompt the agent: 'Bookmark this URL, tag it #research, and add a date node for today.' The agent uses add_url_bookmark and then runs add_tagged_node combined with add_date_node, creating a perfectly labeled, time-stamped resource.
Developing a new content template
A Content Strategist needs a standardized format for all client proposals. They first run define_supertag to create 'Proposal' and then use the agent to execute a command that builds a base node structure using add_node_with_fields, which includes placeholders for budget, timeline, and contacts.
Connecting related ideas across projects
An Engineer finds an old concept note. Instead of rewriting the idea, they prompt the agent to 'Link this node to the main API deprecation project.' The agent uses add_node_reference, keeping the original text intact but establishing a clear, traceable link in the graph.
The Tradeoffs
Using basic nodes for classified data
Writing 'Project Alpha' and manually typing #project into it. This is fragile because the structure isn't enforced, making searching difficult later.
→
Always use add_tagged_node with the appropriate Supertag ID. This guarantees that the node gets the correct classification metadata required for reliable graph queries.
Trying to build an outline manually
Creating a parent note and then having to individually click into it and create every single child node one by one.
→
Run add_node_with_children. This tool builds the entire hierarchy instantly, giving you all required sub-nodes from a single prompt command.
Overwriting structured data
Trying to paste complex JSON or structured form data into a regular note body. The formatting gets lost and is hard for other systems to read.
→
Use add_node_with_fields. This tool is designed to accept specific field names, Supertag IDs, and raw JSON objects, preserving the data's intended structure.
When It Fits, When It Doesn't
Use this MCP server if your primary goal is not just storing information, but structuring it. If you need to build a network of relationships between defined concepts—where nodes must belong to specific types (like #meeting or #client)—you need Tana.
Don't use this if: 1) You are writing quick, disposable thoughts that won't be referenced later. Use your basic text editor instead. 2) Your workflow is simple note-taking and you don't care about taxonomy or hierarchy. If a tool only needs to do one thing (like just adding a date), the dedicated add_date_node is better than trying to use general node creation.
The key difference: This server lets your agent move beyond 'write this text' commands and execute complex, multi-step data modeling operations involving Supertag definition (define_supertag) through to final data injection.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Tana. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Manually building a knowledge graph is slow. It requires copy/pasting and endless clicking.
Today, if you document meeting notes or research findings, you spend time manually creating the structure: You open the note, create subheadings (children), then go back to define what kind of information that subheading represents (tagging/Supertags). Finally, you have to track down and link those ideas to existing projects by copying node IDs.
With this MCP server, your agent handles all that setup. You just prompt: 'Create the Q3 plan.' It automatically runs `add_node_with_children` for the outline, uses `define_supertag` if needed, and applies `add_tagged_node`. The whole structured knowledge graph appears instantly.
The Tana MCP Server: Build graphs with simple prompts.
Previously, every time you captured an idea or link, you had to remember which tool was needed—was it a reference (`add_node_reference`)? Was it a task (`add_checkbox_task`)? Did it need structured fields (`add_node_with_fields`)? This decision process slows down the entire capture loop.
Now, your AI client acts as the architect. You give it the goal, and it executes the necessary sequence of tools—all in one prompt call. It's not just writing text; it's engineering a database entry.
Common Questions About Tana MCP
How do I start using Supertags with Tana MCP Server? +
You must first run define_supertag to establish the official schema (e.g., 'Client'). After defining it, use add_tagged_node and pass the specific Supertag ID when creating a note.
Is Tana MCP Server only for text nodes? +
No. It handles multiple data types. You can create simple tasks with add_checkbox_task, track time using add_date_node, or link to external sites via add_url_bookmark.
What’s the difference between add_node and add_to_inbox? +
Using add_to_inbox is a quick drop for an unclassified node. Use add_node when you need to guarantee that the new note lands in a specific, known location like 'LIBRARY' or a project ID.
Can Tana MCP Server build complex nested notes? +
Yes. You use add_node_with_children to create a parent node, and then the agent can follow up by using add_checkbox_task or other tools on those newly created children.
If the target node ID is invalid, what happens when I use `add_node_reference`? +
The operation fails immediately. The system cannot create a link to an ID that doesn't exist in your graph. Always validate the source node ID before calling add_node_reference.
What format must I use when calling `add_date_node`? +
The input date string must strictly follow the YYYY-MM-DD format. The tool won't parse other formats, so ensure your data is formatted correctly before execution.
Does running `define_supertag` affect existing nodes? +
No, defining a supertag only updates the schema, not the content of any node. Existing nodes retain their structure regardless of new supertags you define with this tool.
What limitations apply if I use `add_checkbox_task`? +
This tool creates a specific type of interactive task element. It doesn't support complex nested children, only the base checkbox functionality within your Tana graph.
Can it apply Supertags with pre-filled fields? +
Yes. Use add_node_with_fields to create a node with a specific Supertag and populate its attributes in a single call.
Are there limits on nested hierarchies? +
No practical limits beyond your token window. The add_node_with_children tool accepts arrays of child nodes and populates the hierarchy in a single request.
Which Tana plan is required? +
API access is available on Tana Plus and Pro plans. Free accounts do not have API tokens. Generate your token from Workspace Settings in the Tana web app.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Percentage Calculation Engine
Stop LLMs from miscalculating discounts and interest. Deterministically calculate exact percentages and relative increases.
Open-Meteo Weather Forecast
Give your AI agent live weather intelligence: 16-day forecasts, current conditions, and hourly breakdowns for any GPS coordinate on Earth — zero API keys required.
MagicBell
Manage notifications and broadcasts via MagicBell — list, retrieve, and trigger multi-channel alerts directly from your AI agent.
You might also like
MINDBODY Health & Wellness
Manage your wellness business via MINDBODY — track class schedules, client profiles, and visit history directly via AI.
AT&T 5G
Access Open Gateway 5G Network APIs -- Number Verify, Device Location, SIM Swap detection, Quality on Demand, and Network Slicing via AT&T.
Beamer
Manage product updates and user feedback via Beamer — create posts, track analytics, and monitor feedback directly from any AI agent.