TeamGantt MCP for AI. Update tasks and track resources using conversation.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
How this MCP server connects to your AI agent
TeamGantt gives you conversational control over complex project timelines. It connects your AI client directly to your Gantt data so you can manage tasks, assign resources, and track dependencies without touching a dashboard.
You tell the agent what needs changing—like 'Mark Task X as 100% done' or 'List all resources needed for Q4'—and it updates the timeline instantly.
What AI agents can do with TeamGantt Automation
Link tasks dependency
Creates a required link between two tasks to enforce a start/end sequence.
Create new task
Adds a new task to your project timeline.
Remove task
Deletes an existing task from the project timeline.
Get a list of all active projects or pull deep metadata for any specific Gantt chart.
Create, update the dates on, or delete individual tasks within a specified project.
Link two tasks together to enforce a sequence (e.g., Task A must finish before Task B starts).
List all available users and equipment, helping you optimize team assignment across projects.
Retrieve a list of major goals or review the checklist for sub-tasks associated with a milestone.
Ask an AI about this
Waiting for input…
What AI agents can do with TeamGantt: 12 Tools for Project & Task Management
These tools let you run every project management function—from listing projects to linking complex task dependencies—all through simple text commands.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using TeamGantt on VinkiusLink Tasks Dependency
Creates a required link between two tasks to enforce a start/end sequence.
Create New Task
Adds a new task to your project timeline.
Remove Task
Deletes an existing task from the project timeline.
Get Task Checklist
Lists all sub-tasks that belong to a parent task.
Get Account Profile
Retrieves basic information about your user account.
Get Project Details
Fetches detailed information and configuration for a specific project.
Get Task Info
Retrieves full details, status, and dates for one specific task.
List Project Milestones
Lists the major, high-level goals set for a project.
List Projects
Retrieves a master list of all projects in your TeamGantt account.
List Available Resources
Shows you all available personnel and equipment listed in your account.
List Project Tasks
Gets a list of all tasks within an entire project timeline.
Update Task Fields
Changes a task's status, dates, or completion percentage.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The TeamGantt integration is available immediately — no restart needed.
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 TeamGantt, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ 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
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by TeamGantt. 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
Built on the Model Context Protocol (MCP) for 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 connection provides 12 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Project status checks are tedious; they require opening multiple tabs just to get an overview., Solved with Vinkius AI Gateway
Today, checking a project's true status means navigating three different views: the master project list, the resource calendar for team availability, and then drilling into task details. You copy dates here, check dependencies there, and paste it somewhere else to summarize the risk. It’s slow, and you always miss something.
With this MCP server, that manual process is gone. You simply ask your agent: 'What's the current status of Project Alpha?' The agent calls `get_project_details` and gives you a single, synthesized answer covering timelines, resource gaps, and task progress.
TeamGantt MCP Server updates project data instantly.
Before, updating one small item—like changing the completion percentage on 'API Integration' from 85% to 90%—required logging into the web app and hitting save. If you missed a step or couldn't get to the right task ID, the whole process stalled.
Now, your AI client handles it. You tell it: 'Update task 123 to 90% complete.' The agent runs `update_task_fields` directly and confirms the change instantly. It’s that reliable automation that changes how you work.
What your AI can actually do with this
Listen, forget logging into a massive dashboard just to change a date or check who's available. This server hooks your AI client right up to TeamGantt data, letting you run complex project management commands purely through natural conversation. You don't touch the graphical interface; you just tell your agent what needs fixing, and it updates the entire timeline instantly.
Getting a Read on Your Workload
You can start broad or get surgical with the metadata. Need to know everything going on? Use list_projects to pull a master list of every project in your account. If you zero in on one job, get_project_details fetches all the deep configuration and details for that specific Gantt chart.
From there, you can get an overview using list_project_tasks, which gives you a full rundown of every single task currently tracked in that timeline.
Deep Task Dive and Management
When you need specifics, you've got options. If you want the status and date range for one particular item, run get_task_info. But if you need to see what smaller steps make up a big parent task, use get_task_checklist to list all those sub-tasks associated with it.
You can manage the core tasks themselves—you'll never have to manually update a percentage again because you've got update_task_fields, which lets you change a task’s status, adjust its completion percentage, or shift its dates directly via chat. If something is finished and needs to go, use remove_task to delete it from the timeline.
And if you gotta put something new on the board? Just kick off create_new_task, and it'll show up right where it belongs.
Connecting Tasks and Goals
Project logic is what keeps things running smoothly, and that’s where dependencies come in. You can use link_tasks_dependency to enforce a strict sequence between two tasks—say, Task A has to finish before Task B even starts. This keeps your project timeline sound automatically. For high-level goals, you'll pull the major markers using list_project_milestones.
If you want to review the smaller components needed to hit that milestone, you can check the associated sub-task checklists.
Staffing and Resources
Knowing who's doing what is key. You can get a full picture of your team or gear by running list_available_resources, which shows all personnel and equipment listed in your account for optimal assignment across multiple jobs. If you need to check the general details of your account, use get_account_profile to pull basic user information.
019dd16f-ab58-71c9-ba59-5126abe3ba49 
Here's how it actually works
The bottom line is that you manage your entire project lifecycle using simple text commands instead of clicking through tabs and forms.
First, subscribe to the TeamGantt server and input your API Token into your client settings.
Next, prompt your agent using natural language—for example: 'Show me tasks for Project X.'
The agent calls the necessary tools (list_project_tasks or get_task_info), pulls the data, and provides a conversational summary.
Who is this actually for?
Project Managers who hate manually updating timelines. Ops Engineers who need to verify resource availability across multiple departments. Engineering Leads responsible for hitting milestones and ensuring task dependencies don't break the schedule. If your job involves coordinating more than three people, this is for you.
Uses list_projects to see all active timelines. Then uses get_task_info and update_task_fields to quickly mark tasks as complete or adjust dates when scope changes.
Runs list_available_resources to check if the team has capacity for a new project. They use this data to plan and assign resources before kickoff.
Monitors major goals by calling list_project_milestones. When a milestone is near, they check sub-tasks using get_task_checklist.
What Changes When You Connect
Stop clicking through dashboards. You can update a task's progress or change its due date just by telling the agent, saving you minutes on every single project status report.
Resource planning is instant. Calling list_available_resources gives you an immediate inventory of people and gear, so you stop guessing if your team has capacity for that new feature build.
Dependencies are guaranteed. Use link_tasks_dependency to enforce hard rules—like 'design must finish before coding starts.' The agent makes sure the timeline logic holds up.
Never lose track of a goal again. Run list_project_milestones to see all major project goals and then drill down with get_task_checklist for sub-tasks that need attention.
Full Project Visibility: You don't have to open the web app. Use list_projects to get a summary of every timeline you manage, making it easy to check which projects are stalled.
See it in action
Project scope shifts mid-sprint
The client just dropped a major new feature. Instead of manually editing 15 tasks and recalculating dates, you ask your agent: 'Add Task Y to Project Alpha.' The agent uses create_new_task and intelligently adjusts the surrounding timeline for you.
Need to check team capacity
Before accepting a new contract, you need to know if your developers are free. You run list_available_resources. If the agent shows only 2 engineers available, you immediately flag the client that resource allocation is an issue.
Fixing broken project logic
Task B can't start until Task A finishes. You suspect a link is missing. You tell your agent to link_tasks_dependency between the two tasks, and it verifies the relationship, preventing scheduling errors.
Quarterly planning review
You need an overview of everything planned for Q4. You ask the agent to 'List all milestones for the next quarter.' The tool runs list_project_milestones and gives you a clear, actionable summary instead of just links to a dashboard.
The honest tradeoffs
Trying to update dates manually
Typing out 'Update task ID 88231: Start date is next Tuesday, end date is Friday.' into the chat.
Use update_task_fields. Just tell your agent: 'Set task 88231 dates to start next Tuesday and finish Friday.' The tool handles the syntax correctly.
Forgetting dependencies
Marking a downstream task as complete even though its prerequisite (Task A) hasn't been finished.
Always run link_tasks_dependency first. This tool locks the relationship, forcing the agent to warn you if the sequence is violated.
Asking for general 'project status'
A vague prompt like: 'How's the project going?' The agent can't guess what you mean.
Be specific. Use list_project_tasks followed by a direct command, such as: 'List tasks for Project Beta and tell me which ones are below 50% completion.'
When It Fits, When It Doesn't
Use this server if your primary need is managing complex, multi-stage workflows where task relationships (dependencies) and resource allocation matter. You're dealing with a formal project timeline that must be accurate.
Don't use it if you just need simple checklists or quick notes. If all you need to track is 'Buy milk' and 'Walk dog,' this is overkill. For those basic tasks, a simple note-taking app works better. However, if your checklist items are structured (e.g., 'Draft Copy' -> 'Legal Review' -> 'Final Approval'), then use the tools here like get_task_checklist to enforce that structure.
If you need to know what was done, but not when, a simple document tracker is enough. But if the timing and who does it matters—if Task B absolutely cannot start until Task A finishes—you need this server.
Questions you might have
How do I start a new task with TeamGantt using create_new_task? +
Just tell your agent to 'Create a new task called Beta Testing.' The create_new_task tool adds it to the project, and you can then use get_task_info to check its initial details.
What is the difference between list_project_tasks and get_task_info? +
list_project_tasks gives you a broad summary of every task in a project. get_task_info pulls all the deep, specific metadata—like exact dates or resource owners—for one single task.
Can I link tasks with TeamGantt using link_tasks_dependency? +
Yes. You prompt the agent to link_tasks_dependency between Task A and Task B. This makes it mandatory that Task A must finish before Task B can start, keeping your timeline clean.
Does TeamGantt have a way to check resource availability? +
Use the list_available_resources tool. It shows you who's free and what equipment is available so you don't over-allocate people when planning.
How do I use `remove_task` to delete a task from my project? +
You must specify the exact Task ID when calling remove_task. The tool permanently deletes the item, so double-check that you don't need it first. You can verify the current tasks using list_project_tasks before running this command.
What project metadata do I get using `get_project_details`? +
This tool returns the core configuration and detailed metadata for an entire project timeline. It shows things like overall project start/end dates, associated departments, and high-level status flags. Use this before managing individual tasks.
Should I use `list_project_milestones` instead of looking at regular tasks? +
Milestones represent major, high-level goals that mark significant project stages. They are different from standard tasks because they don't require daily work logs; they just flag completion of a large objective.
How does `update_task_fields` change the status or dates for a task? +
update_task_fields lets you modify key parameters like the progress percentage, due date range, and overall status. You must provide the Task ID along with the specific fields (e.g., 'status: complete' or 'progress: 75%') in your request.
Can I see all the tasks in a project via AI? +
Yes! Use the list_project_tasks tool and provide the Project ID. Your agent will retrieve all tasks, milestones, and groups for that specific Gantt chart.
How do I update the progress of a task using the agent? +
Use the update_task_fields action. Provide the Task ID and the percentComplete value (0-100) to update the task's status instantly.
Is it possible to link two tasks with a dependency via AI? +
Absolutely. Use the link_tasks_dependency tool. Provide the ID of the predecessor and the successor tasks to create a Gantt link between them.
We've already built the connector for TeamGantt. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 12 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.