Poké MCP for AI. Pull structured data on Pokémon mechanics and items.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Poké connects your AI client directly to the PokéAPI for deep Pokémon data retrieval. Query everything from specific berry flavors and contest type mechanics to wild encounter conditions and evolution chains.
You can list all items, check item attributes, or get details on a single location using granular tools like `get_berry` and `list_items`.
Stop guessing game lore; pull structured data directly into your chat.
What your AI can do
Get berry firmness
Gets the firmness level data for a specified berry.
Get berry flavor
Retrieves details about a berry's flavor profile (e.g., spicy, sweet).
Get berry
Retrieves specific details about a single type of berry.
List all available berries and retrieve detailed data on their firmness levels and flavor types.
Query contest type rules and effects to understand how different moves score points in competition.
Find the conditions and methods Pokémon use when they appear in the game world (e.g., tall grass, fishing).
Get specific properties of any item—its category, attribute, or even its pocket contents.
Retrieve the steps and triggers required for a Pokémon to evolve from one stage to another.
Ask an AI about this
Waiting for input…
Poké MCP Server: 49 Tools for Pokémon Data Retrieval
Access granular tools covering every aspect of the Pokémon world, from listing items to querying complex evolution chains.
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 Poké on VinkiusGet Berry Firmness
Gets the firmness level data for a specified berry.
Get Berry Flavor
Retrieves details about a berry's flavor profile (e.g., spicy, sweet).
Get Berry
Retrieves specific details about a single type of berry.
Get Contest Effect
Gets the specific effect generated by a contest move or type.
Get Contest Type
Retrieves details about a particular contest type (e.g., 'cool', 'elegant').
Get Encounter Condition
Gets the general condition required for a Pokémon encounter.
Get Encounter Condition Value
Retrieves specific values associated with an encounter condition (e.g., 'grass', 'water').
Get Encounter Method
Gets details on a method used to trigger a wild Pokémon encounter.
Get Evolution Chain
Retrieves the sequence of stages and steps required for a Pokémon's evolution.
Get Evolution Trigger
Gets details on what causes an evolution to happen (e.g., 'level up', 'item').
Get Generation
Retrieves information regarding a specific generation of Pokémon.
Get Item Attribute
Retrieves specific attributes (like flammable or healing) associated with an item.
Get Item Category
Gets the general category an item belongs to.
Get Item Fling Effect
Retrieves details on what happens if a player throws the item incorrectly.
Get Item Pocket
Gets information about where an item can be stored or found in a pocket.
Get Item
Gets full data, including uses and properties, for any given item.
Get Location Area
Gets information about the larger area containing a location.
Get Location
Retrieves details for a specific geographical location within the game world.
Get Pal Park Area
Retrieves details specific to Pal Park areas.
Get Pokedex
Gets comprehensive data for a single Pokémon entry in the Pokédex.
Get Region
Retrieves details about a specific geographical region (e.g., Kanto, Paldea).
Get Super Contest Effect
Gets the mechanics and effects related to super contests.
Get Version Group
Gets details regarding a group of related game versions.
Get Version
Retrieves version-specific data about the game release or update.
Query Graphql
Executes a complex GraphQL query against the entire PokéAPI dataset.
List Berries
Provides a list of every type of berry available in the database.
List Berry Firmnesses
Lists all known firmness types for berries.
List Berry Flavors
Outputs a list of distinct berry flavor profiles (e.g., spicy, sour).
List Contest Effects
Returns an enumeration of all possible contest effects.
List Contest Types
Outputs a list of distinct contest types available in the game.
List Encounter Condition Values
Lists specific values that define an encounter condition (e.g., 'tall grass').
List Encounter Conditions
Outputs a list of all possible conditions used for Pokémon encounters.
List Encounter Methods
Provides an enumeration of how players can encounter wild Pokémon.
List Evolution Chains
Lists every documented evolution chain in the game's history.
List Evolution Triggers
Outputs a list of all ways an evolution can be triggered (e.g., 'level up', 'trade').
List Generations
Lists the different generations of Pokémon documented.
List Item Attributes
Provides a list of all known item attributes (e.g., flammable, healing).
List Item Categories
Outputs a comprehensive list of item categories.
List Item Fling Effects
Lists all possible negative outcomes when an item is thrown wrong.
List Item Pockets
Provides a list of locations or types of pockets where items can be stored.
List Items
Lists every item available in the game's database.
List Location Areas
Outputs a list of major, defined geographical areas.
List Locations
Lists every specific point or location within the game world map.
List Pal Park Areas
Outputs a list of areas specific to Pal Park.
List Pokedexes
Lists every available Pokédex entry or guide.
List Regions
Outputs a list of known Pokémon regions (e.g., Johto, Paldea).
List Super Contest Effects
Lists all possible super contest effects.
List Version Groups
Outputs a list of version groups for related game updates.
List Versions
Provides a list of specific versions or patches available for the API.
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.
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 Poké, 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 PokéAPI. 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 connection provides 49 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Writing about game mechanics requires cross-referencing dozens of tabs and wikis.
Today, writing a comprehensive guide on berries means opening the item wiki for basic stats, then checking a separate battle simulator to see how they affect contests. You're copying data from three different sources: one page for listing all berries (`list_berries`), another for flavor profiles (`get_berry_flavor`), and yet a third place just for contest rules.
With this server, you ask your agent once: 'What are the mechanics of Oran Berries?' The agent runs `get_berry` and synthesizes the data into one clean answer. You get accurate, structured facts without ever leaving your chat.
Poké MCP Server lets you extract precise Pokémon data points.
Manual data gathering involves running separate searches for everything: first listing all item categories (`list_item_categories`), then finding the specific item, and finally calling a getter like `get_item_attribute` to find its function. This is slow and error-prone.
Now, you ask your agent directly: 'What are the flinging effects of this item?' The server handles the sequence internally, returning only the precise effect data. It's immediate, accurate, and keeps your workflow in one place.
What your AI can actually do with this
*Listen up. This server hooks your AI client right into the PokéAPI. You're getting deep data on every single thing in the Pokémon universe—items, locations, mechanics. Forget relying on fan wikis or guessing game lore; you pull structured facts straight into your chat.
Analyze Berry Properties
- To check out berries, you can start by running
list_berriesto get a full rundown of every berry type available. From there, you'll useget_berry_firmnessorget_berry_flavorif you wanna know specifics about its physical properties or taste profile. You gotta runlist_berry_firmnessesandlist_berry_flavorsto see all the possible variations for those getters.
Map Contest Mechanics
- If you're deep into contest theory, you can use
list_contest_typesto get a list of every contest type out there. Then, when you know which type it is—like 'cool' or 'elegant'—you runget_contest_typefor the details. To understand how moves score points in competition, check outlist_contest_effects, and useget_contest_effectto find the specific effect generated by a particular move or type.
Determine Encounter Rules
- Figuring out how Pokémon actually appear in the wild is straightforward. You start by listing all possible conditions with
list_encounter_conditionsand getting general data withget_encounter_condition. For specifics, you check tools likeget_encounter_condition_value, which tells you the exact condition—like 'grass' or 'water'. To see how players trigger a wild encounter, runlist_encounter_methodsto get all options (you know, walking around, fishing). Then you useget_encounter_methodfor details on that specific method. For the values associated with those methods, check outget_encounter_condition_value.
Detail Item Attributes & Contents
- When you need item data, start by running
list_items; this spits out every single usable object in the game. To get full details on any specific item, useget_item, which covers uses and properties. If you wanna know if that item is flammable or helps heal, you runget_item_attributefor those specifics. You can find out what general group an item belongs to usingget_item_category, and where it lives by checking its pocket data withget_item_pocket. Wanna know what happens when someone throws the item wrong? Useget_item_fling_effect, or check all possible outcomes usinglist_item_fling_effects. To get a general idea of storage, you runlist_item_attributesandlist_item_categories; for pockets, uselist_item_pockets.
Trace Evolution Chains
- Tracking how Pokémon change is simple. You can start by listing all documented evolution chains with
list_evolution_chains. To see the full sequence of stages and steps needed for any creature to evolve, you runget_evolution_chain. If you need to know what makes it happen—is it leveling up or an item?—useget_evolution_triggerto list all ways evolution can be prompted. For details on a specific trigger, useget_evolution_trigger.
Location and Regional Data
- For maps and geography, you can run
list_regionsto see every major area (like Paldea or Johto). To get deep info on a specific region, callget_region. If you need details for an actual town or spot, uselist_locations, then pull the data withget_location. For bigger areas that contain multiple spots, check outlist_location_areasand runget_location_area. You can also get Pal Park-specific area info usinglist_pal_park_areasandget_pal_park_area. When you need to know about a specific patch or update, uselist_versionsandget_version, or check out related updates withlist_version_groupsandget_version_group.
Global Data Retrieval
- You can get comprehensive data on any single Pokémon using
get_pokedexafter runninglist_pokedexes. To see all berries, runlist_berries; for item types, uselist_items; and to check out the full list of available pockets, you've gotlist_item_pockets. If you need a general overview of what exists in the world, hit upquery_graphqlto execute a complex query against the entire dataset.
019e38d8-bfd0-70da-ae42-51435a71406f Here's how it actually works
The bottom line is that this server turns complex database lookups into simple chat commands, letting your AI agent pull specific game data instantly.
First, tell your AI agent which data set you need (e.g., 'List all berries' or 'What is the effect of contest type X?').
The agent calls the specific tool (like list_berries or get_contest_effect) to pull structured data from the PokéAPI.
You get a clean, readable list or object containing the precise mechanics and details you asked for, ready to use in your writing or code.
Who is this actually for?
Game developers, technical writers for wikis, and content creators who need precise lore details. If you're the person constantly cross-referencing in three different tabs—one for items, one for mechanics, and a third for location data—you need this. Stop relying on outdated fan guides.
Uses get_item and list_item_attributes to verify item properties or check if a move's effect works correctly before coding mechanics.
Runs list_berries followed by get_berry_flavor when writing guide entries, ensuring the lore about specific items is 100% accurate without leaving their editor.
Uses query_graphql to pull comprehensive, structured lists of relationships between regions, locations (get_location), and available data points for analysis.
What Changes When You Connect
Verify item properties instantly. Instead of cross-referencing guides, use get_item to find an item's attribute or category directly in your chat window.
Map out wild encounters precisely. Use list_encounter_methods to see how Pokémon appear and then run get_encounter_condition to know the exact required condition (e.g., 'tall grass').
Build accurate lore guides. Need to write about a berry? Run list_berries first, then use get_berry_flavor for specific details like 'spicy' or 'dry'.
Understand battle mechanics quickly. Use get_contest_type and list_contest_effects to see exactly how moves score points in a contest.
Trace creature evolution efficiently. Use list_evolution_chains to map out the entire progression, then use get_evolution_trigger to state what causes it (e.g., 'level up').
Handle complex queries with GraphQL. When specific tools aren't enough, run a single query_graphql call for maximum data density.
See it in action
Writing a Guide on Rare Berries
A writer needs to write about the 'Oran Berry.' Instead of searching multiple wikis, they ask their agent: 'What are the flavor and firmness details for Oran Berries?' The agent runs get_berry and then get_berry_flavor, immediately returning structured data (Flavor: Orange; Firmness: Medium) that can be pasted directly into the guide.
Checking Battle Rules
A developer is designing a new contest move. They ask, 'What are the effects of the 'cool' contest type?' The agent runs get_contest_type and list_contest_effects, detailing exactly how that type impacts point scoring for moves in competition.
Mapping a New Gym Location
A data analyst needs to know all potential encounter methods at a new gym. They run list_encounter_methods. The agent returns options like 'walk' and 'old-rod,' allowing the analyst to systematically map out every possible way a Pokémon could appear in that area.
Debugging an Item Interaction
A content creator needs to know why throwing a specific item causes damage. They ask, 'What is the fling effect of this item?' The agent runs get_item and specifically calls get_item_fling_effect, providing the exact mechanical consequence for fact-checking.
The honest tradeoffs
Asking general questions about mechanics.
Agent: 'Tell me everything about berries and contests.' Result: A massive wall of unrelated text, making it hard to find the specific flavor or type data you need.
Break it down. First, use list_berries to narrow the scope. Then, ask for specifics using get_berry_flavor or get_berry_firmness. Specific tools give precise answers.
Relying only on general listing tools.
Agent: 'List all items.' Result: A huge list of 10,000+ item IDs. You still have to manually check each one for its attribute or category.
Use list_items only to find the name/ID first. Then, follow up with a targeted getter like get_item_attribute to pull only the specific data point you need.
Assuming one tool covers everything.
Trying to get location details by just running list_locations, but needing regional context. The list is too broad and lacks area information.
Always check the parent-area first. Run list_location_areas to find the macro region, then use get_location_area before querying a specific location with get_location.
When It Fits, When It Doesn't
Use this server if your goal is data verification or systematic research into game mechanics. If you need to know 'What are all the things?' (e.g., use list_items), start there, then narrow it down.
Don't use it if you just want general background information that doesn't require structured data—for example, describing a Pokémon's personality is outside its scope. If your question can be answered with a simple 'yes' or 'no,' the tool probably isn't needed.
Use this when you need to map relationships: For instance, if you want to know which item belongs to which category, run list_item_categories first. Then, for precise data points—like checking a berry's flavor—use the dedicated getter (get_berry_flavor). Don't try to use one tool to do everything; chain them.
Questions you might have
How do I find out what a Pokémon can evolve into using get_evolution_chain? +
Running get_evolution_chain provides the full sequence of stages. It tells you not just the next stage, but also the necessary trigger (e.g., 'level up' or 'trade') to make it happen.
What is the difference between list_items and get_item? +
list_items provides a simple inventory of every item ID available in the database. get_item, however, retrieves the full data object for that specific item—including its category and attributes.
Can I use get_encounter_condition to find out how Pokémon appear? +
Yes. You should pair it with list_encounter_methods. First, run list_encounter_methods (e.g., 'walk'). Then, use the method name in a query to narrow down specific conditions using get_encounter_condition.
How do I compare item attributes across different items? +
You run list_item_attributes first to see all possible types (like 'flammable'). Then, you can use get_item_attribute multiple times for different items to build a comparative list.
Which tool should I use if I need general API data? Should I use query_graphql? +
If you know the exact function (e.g., finding berry flavor), use the specific getter (get_berry_flavor). Save query_graphql for truly complex, multi-entity queries where no single tool exists.
If I query a large dataset using list_pokedexes, how does the server handle rate limits? +
The server manages standard API rate limiting. If your agent client hits a limit, it must implement an exponential backoff retry loop to wait and re-attempt the call later. This prevents connection failures.
Do I need specific credentials or keys just to use get_item details? +
No, this server uses public endpoint data and requires no complex API keys. Your AI client connects directly without needing authentication tokens for basic lookups of item information.
Should I use list_items or list_item_categories if I'm grouping items? +
You should use list_item_categories first to get the structured group names. Then, you can use get_item with a specific ID to pull the detailed data for any item within that category.
How can I find the specific details of a berry by its name? +
Use the get_berry tool and provide the name (e.g., 'cheri'). The agent will return its growth time, max harvest, size, and smoothness.
Can I list all the different ways a Pokémon can be encountered? +
Yes, use the list_encounter_methods tool. It provides a paginated list of all methods like 'walk', 'old-rod', or 'surf' used in the games.
Is it possible to check the effects of Pokémon Contests? +
Absolutely. You can use list_contest_effects to see available effects or get_contest_effect with a specific ID to see the detailed appeal and jam metadata.
We've already built the connector for Poké. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 49 tools are live and waiting.
You're up and running in seconds.
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.