Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@GSAP MCP Server Create a scroll-triggered parallax effect for .parallax"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A comprehensive GSAP animation MCP server for Claude Code integration, providing seamless access to all GSAP features through the Model Context Protocol.
gsap-animate: Create animations using gsap.to(), gsap.from(), and gsap.fromTo()
gsap-set: Instantly set CSS properties without animation
gsap-timeline: Create and manage complex animation sequences
gsap-kill-tweens: Stop and control running animations
gsap-scroll-trigger: Scroll-based animations with ScrollTrigger
gsap-motion-path: Animate elements along custom paths
gsap-draggable: Create interactive draggable elements
gsap-morph-svg: SVG shape morphing (premium plugin)
gsap-split-text: Advanced text animations (premium plugin)
gsap-page-transition: Smooth page transitions
gsap-parallax: Parallax scrolling effects
gsap-stagger: Advanced staggered animations
gsap-selector: Smart element selection and validation
gsap-easing: Explore and create custom easing functions
gsap-performance: Monitor and optimize animation performance
Animation presets and templates
GSAP API documentation
Code examples and tutorials
Performance optimization guides
Related MCP server: GSAP-Animation-Generate
npm install gsap-mcp-serverAdd the server to your Claude Code configuration:
claude mcp add gsap-server /path/to/gsap-mcp-serverOr add to your settings.json:
{
"mcpServers": {
"gsap-server": {
"command": "node",
"args": ["/path/to/gsap-mcp-server/dist/index.js"]
}
}
}Start using GSAP tools in Claude Code:
Use the gsap-animate tool to create a fade-in animation for .hero-title# Install dependencies
npm install
# Build the project
npm run build
# Run in development mode
npm run dev
# Run tests
npm test
# Lint code
npm run lint// Generated code example
import { gsap } from 'gsap';
gsap.to('.element', {
x: 100,
opacity: 1,
duration: 1,
ease: 'power2.out'
});// Generated code example
const tl = gsap.timeline();
tl.to('.box1', { x: 100, duration: 1 })
.to('.box2', { y: 100, duration: 1 }, '-=0.5');// Generated code example
gsap.to('.parallax', {
y: -100,
ease: 'none',
scrollTrigger: {
trigger: '.container',
start: 'top bottom',
end: 'bottom top',
scrub: true
}
});The server includes built-in performance monitoring and optimization suggestions:
GPU acceleration recommendations
Memory usage tracking
Frame rate monitoring
Animation complexity analysis
MIT
Contributions are welcome! Please read our contributing guidelines and submit pull requests to our repository.
For support and questions:
Check the documentation
Open an issue on GitHub
Visit the GSAP community forums
🎯 Generated with Claude Code - Bringing GSAP animations to your development workflow with intelligent assistance.
Create GSAP animations using to(), from(), or fromTo() methods
| Name | Required | Description | Default |
|---|---|---|---|
| ease | No | Easing function (power1, power2, back, bounce, etc.) | |
| type | Yes | Type of animation: to, from, or fromTo | |
| delay | No | Delay before animation starts | |
| duration | Yes | Animation duration in seconds | |
| selector | Yes | CSS selector for target elements | |
| properties | Yes | Animation properties (transforms, styles, etc.) | |
| fromProperties | No | Starting properties for fromTo animations |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are given, so the description carries full burden. It does not disclose behavioral traits such as side effects on existing animations, whether it modifies DOM directly, or potential performance implications. For a mutative tool, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It efficiently states the core action, though it could benefit from slightly more detail without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 7 parameters (4 required) and nested objects, the tool is complex. The description does not explain the differences between animation types, how to use 'fromProperties', or expected outcomes. No output schema further reduces completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all 7 parameters. The description adds no additional semantic meaning, such as explaining how 'fromProperties' differs from 'properties' or providing examples. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Create' with the resource 'GSAP animations' and explicitly lists the three animation methods (to, from, fromTo). This clearly distinguishes the tool from siblings like gsap-stagger or gsap-draggable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool vs alternatives. It does not mention prerequisites, preferred use cases, or exclusions, leaving the agent to infer context from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create draggable elements with GSAP Draggable
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | CSS selector for draggable elements |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden but only states 'Create draggable elements'. It does not disclose side effects, return values, prerequisites (e.g., loading GSAP), or any behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no superfluous words. It is concise and front-loaded, with every word earning its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one parameter and no output schema, the description is sparse. It omits crucial context such as return values, library dependencies, or interaction with other GSAP tools, making it incomplete for a full understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The parameter 'selector' is well-documented in the schema with 'CSS selector for draggable elements', and schema coverage is 100%. The description adds no additional parameter semantics beyond what the schema provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'create' and resource 'draggable elements' and references GSAP Draggable, making the purpose unambiguous. However, it does not differentiate from sibling tools like gsap-animate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as gsap-animate or gsap-stagger. The description lacks any context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Explore GSAP easing functions
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Easing action |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility but only says 'explore', omitting any behavior details such as side effects, output format, or action differences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short but lacks necessary detail; conciseness is undermined by under-specification.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single parameter with enum and no output schema, the description is incomplete—failing to explain the purpose of each action or expected output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no meaning beyond the schema's enum and 'Easing action' description; it does not explain what the 'list' and 'test' actions entail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Explore GSAP easing functions' is vague and does not specify what the tool actually does (list vs test) nor differentiate it from sibling tools like gsap-animate or gsap-draggable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool or how it compares to alternatives; the description offers no context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Morph SVG shapes (requires GSAP Club membership)
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | SVG path selector |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only discloses the membership requirement. It does not explain what the morph does (e.g., animation, immediate transformation), side effects, or return behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that conveys the core action and a key prerequisite, with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple tool (1 param, no output schema), the description is too minimal. It lacks context on what morphing entails, expected output, or any setup steps beyond membership.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes 'selector' as 'SVG path selector' with 100% coverage. The description adds no further meaning or usage details for the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'morph' and the resource 'SVG shapes', and the membership requirement helps distinguish it from sibling tools like gsap-animate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives like gsap-animate or other GSAP tools. The description only mentions a membership requirement, not usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create page transitions with GSAP
| Name | Required | Description | Default |
|---|---|---|---|
| type | Yes | Transition type |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as whether it modifies DOM, requires specific HTML structure, or any side effects. The agent gets no additional context beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded, efficient. However, it is arguably too minimal; every sentence should earn its place, and this one barely provides context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description is minimal but lacks details about how the transition integrates with page flow, what elements are affected, or any required setup. Incomplete for confident invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter 'type' described as 'Transition type' and enum values. The description adds no extra meaning beyond the schema, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Create page transitions with GSAP', specifying verb and resource. It distinguishes from sibling tools like gsap-animate (general animation) and gsap-draggable (drag interactions) by focusing on page transitions, though could be more precise.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like gsap-animate or other transition methods. The description does not mention use cases, prerequisites, or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create parallax scrolling effects
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | CSS selector for parallax elements |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description must disclose behavioral traits, but it only states the tool creates parallax effects. It does not mention scrolling triggers, performance implications, or any side effects, leaving the agent with minimal information.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the purpose. It is concise with no wasted words, though it could be slightly expanded for additional clarity without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (parallax scrolling often involves multiple parameters like speed, direction, or trigger), the description is insufficient. No output schema exists, and the description fails to cover typical behavior like scroll-triggered animation or element movement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes the single parameter ('CSS selector for parallax elements') with 100% coverage. The tool description adds no additional meaning beyond restating the tool's purpose, so it meets the baseline but adds no value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Create' and the resource 'parallax scrolling effects', distinguishing it from sibling tools like gsap-animate or gsap-draggable. However, it lacks specificity about what kind of parallax effect or how it's applied.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool over alternatives like gsap-animate or gsap-stagger. Given the sibling list, this omission makes it harder for an agent to choose correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Monitor GSAP animation performance
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Performance action |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden of behavioral disclosure. It only says 'Monitor GSAP animation performance' without detailing what happens (e.g., starts monitoring, returns tips, side effects). The actual behavior for each action is left implicit, lacking transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is concise and front-loaded. However, it may be too terse for the level of detail needed, as it omits important information about the tool's behavior and usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one parameter with enums and no output schema, the description is insufficiently complete. It does not explain the outcome of each action, the output format, or any performance metrics, leaving significant gaps for the agent to infer.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although the parameter 'action' is fully covered in the schema with an enum and descriptions ('Performance action'), the description adds no additional meaning beyond that. The enum values 'monitor' and 'tips' remain unexplained in the description, reducing the value for the agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Monitor GSAP animation performance' clearly states the action (monitor) and resource (GSAP animation performance), and it effectively distinguishes this tool from sibling tools like gsap-animate or gsap-draggable, which focus on creating animations rather than monitoring.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not specify prerequisites, exclude other tools, or explain the difference between the 'monitor' and 'tips' actions. The enum suggests two modes, but their intended use cases are not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Smart element selection and validation for GSAP animations
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Selector action | |
| selector | No | CSS selector to validate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description does not disclose any behavioral traits such as whether the tool modifies state, requires permissions, or what it returns. The brief phrase 'smart element selection and validation' is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single vague sentence. It lacks necessary detail to be useful, so it is under-specified rather than concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with two parameters and no output schema, the description should clarify the meaning of the 'action' values and what the tool returns. It fails to do so, leaving significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema provides descriptions for both parameters with 100% coverage. The description adds no additional meaning beyond what the schema already states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states 'element selection and validation' but doesn't specify the two actions (validate, count) or what validation entails. It's better than a tautology but remains vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No indication of when to use this tool versus sibling tools like gsap-animate or gsap-performance. No usage context or alternatives mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Split text for animations (requires GSAP Club membership)
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes | Text element selector |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description lacks behavioral traits beyond the requirement. With no annotations, the description carries the full burden, but it does not explain what happens when splitting text, side effects, or output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a single sentence, front-loading the core action and a key requirement. However, it could include more context without losing brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and minimal annotations, the description is insufficient. It does not explain what 'split' means, the return value, or behavioral outcomes, leaving gaps for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, so the description does not need to add extra meaning. The description does not add any information beyond the schema's 'Text element selector'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it splits text for animations, using a specific verb and resource. It distinguishes from sibling tools like gsap-animate or gsap-stagger by its unique purpose of splitting text, though it does not explicitly differentiate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The only additional information is a prerequisite (GSAP Club membership), which does not help the agent choose between siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create staggered animations
| Name | Required | Description | Default |
|---|---|---|---|
| stagger | No | Stagger delay between elements | |
| selector | Yes | CSS selector for elements to animate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only states the function. It does not mention that the tool applies animations with delays to multiple elements, the need for a selector matching many elements, or any side effects. The description is insufficient for transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short (two words), which is concise but lacks structure. It is front-loaded with the purpose, but the brevity leaves out important context such as parameter use cases. Every word earns its place, but more could be added without sacrificing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, the description is incomplete. It omits the fact that the tool expects a CSS selector and a stagger delay, and does not mention return values or behavioral constraints. With no output schema, the description should at least hint at the effect or result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for both parameters (selector and stagger). The tool description adds no additional meaning beyond the schema, but the schema already provides adequate parameter info, so baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create staggered animations' clearly states the tool's function with a specific verb and resource (staggered animations). It distinguishes from generic animation tools like gsap-animate by focusing on staggering, but does not explicitly differentiate from other stagger-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidelines are provided. The description does not indicate when to use this tool versus alternatives like gsap-animate or gsap-easing, missing an opportunity to guide the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0gsap-animategsap-draggablegsap-easinggsap-morph-svggsap-page-transitiongsap-parallaxgsap-performancegsap-selectorgsap-split-textgsap-staggerScored across 10 tools
Each tool has a clear and distinct purpose, covering different GSAP features like animation creation, draggable elements, SVG morphing, text splitting, page transitions, parallax, stagger, element selection, and easing exploration. No overlap or ambiguity.
All tools share a consistent 'gsap-' prefix, but the second part varies between nouns (e.g., 'performance', 'draggable') and verb phrases (e.g., 'animate', 'morph-svg'). The pattern is mostly predictable, with minor mix of styles.
With 10 tools, the server covers a broad range of GSAP's core and advanced features without being overwhelming. Each tool serves a distinct and useful purpose, making the set well-scoped for a GSAP-focused MCP server.
The set covers basic animation, advanced effects (draggable, parallax, stagger), and utilities (selector, easing). However, notable gaps exist: no timeline management (e.g., gsap-timeline) and no ScrollTrigger plugin, which are essential for complex GSAP workflows.
Claude Code / MCP skills for the dev pipeline: discover, spec, design, build, ship, operate.
Turn Claude into a creative studio: DNA-locked characters, images, video, voiceover — 55 tools.
Live SEO workflow tools for Claude Code, Codex, and AI agents.
Brand-aware creative studio for Claude: 200+ tools for on-brand ads, video, email and campaigns.
