Operational Summary

Dex-Data-Bridge functions as a Model Context Protocol (MCP) endpoint, offering structured access to creature data. It interfaces directly with the PokeAPI backend to retrieve entries and disseminates this information through MCP tooling consumable by various AI interfaces, including Claude Desktop, Continue, Cline, and associated clients.

Crucially, this service now incorporates HTTP transport capabilities utilizing Server-Sent Events (SSE) to enable continuous, real-time data streaming, moving beyond the legacy stdio communication method.

Capabilities

• Retrieve comprehensive profiles for any Pokémon identified by its nomenclature
• Initiate requests for arbitrarily selected, unique Pokémon entities
• Source a random Pokémon constrained to a specific geographical area (e.g., Kanto, Johto, Hoenn)
• Obtain a randomly chosen specimen defined by its elemental classification (e.g., Fire, Water, Electric)
• Support for conversational interpretation of data requests pertaining to Pokémon lore and attributes

Operational Mechanics

Dex-Data-Bridge is architected around the principles of the Model Context Protocol, which standardizes how intelligent agents interact with external datasets and functionalities. The server sequence involves:

1. Establishing a connection to the PokeAPI endpoint for data acquisition.
2. Exporting a suite of functional tools via the MCP interface.
3. Interpreting incoming requests forwarded by MCP clients.
4. Transmitting the validated Pokémon statistics back to the requester.

Available MCP Constructs

The server exposes the following actionable mechanisms:

• get-pokemon: Fetches in-depth attributes for a Pokémon specified by name.
• random-pokemon: Returns data for an unconstrained, randomly chosen creature.
• random-pokemon-from-region: Acquires a randomized entry limited to a defined territorial scope.
• random-pokemon-by-type: Selects a random Pokémon matching a designated attribute category.
• pokemon-query: Resolves complex, natural language inquiries regarding creature data.

System Foundation

The implementation stack comprises:

• TypeScript language environment
• MCP TypeScript SDK (@modelcontextprotocol/sdk) for protocol handling
• Zod for schema validation and input integrity assurance
• HTTP transport leveraging Server-Sent Events (SSE) for MCP signaling
• Node.js integrated HTTP server module

Deployment Procedures

Automated Setup via Smithery

To provision Dex-Data-Bridge automatically for Claude Desktop integration using Smithery:

bash npx -y @smithery/cli install @NaveenBandarage/poke-mcp --client claude

Manual Repository Integration

bash

Obtain the source repository

git clone https://github.com/yourusername/poke-mcp.git cd poke-mcp

Install necessary dependencies

npm install

Compile the source code

npm run build

Operational Execution

Activating the HTTP Conduit

To initiate the server utilizing the modern HTTP methodology:

bash

Launch server (defaulting to port 3000)

npm start

Alternatively, specify an alternate access port

PORT=8080 npm start

The service endpoints will be accessible at:

• Metadata Endpoint: http://127.0.0.1:3000/ - Server operational status and general information
• Event Stream Endpoint: http://127.0.0.1:3000/sse - Connection point for MCP clients utilizing SSE transport
• Command Endpoint: http://127.0.0.1:3000/message - POST interface for transmitting MCP payloads

Integration with Claude Desktop (SSE Transport)

1. Obtain and install the Claude Desktop Application.
2. Access the settings menu within Claude.
3. Navigate to Developer configuration and modify the underlying configuration file.
4. Embed the subsequent configuration block defining the HTTP transport mechanism:

{ "mcpServers": { "pokedex": { "transport": { "type": "sse", "url": "http://127.0.0.1:3000/sse" } } } }

1. Start the Dex-Data-Bridge service: npm start.
2. Restart the Claude Desktop application.
3. The Pokémon toolset should now be recognized and available within Claude's context.

Previous Communication Method (stdio)

For backward compatibility reasons, the service can still be invoked using the standard input/output stream method by utilizing the deprecated stdio implementation.

Illustrative Interaction Prompts

When the server is successfully linked to an MCP client, queries can be framed as follows:

• "Provide details regarding the creature known as Pikachu."
• "Retrieve a specimen chosen at random."
• "Present a randomly selected Pokémon originating from the Kanto region."
• "Identify a random specimen classified under the Water element."

Component Blueprint

• src/index.ts: Core server execution logic
• src/types.ts: Definitions for Pokémon data structures
• package.json: Manifest of dependencies and execution scripts
• tsconfig.json: TypeScript compiler directives

Extending Functionality

To incorporate novel utilities or refine existing ones:

1. Develop new utility functions for data fetching and output formatting.
2. Register these additions using the server.tool() method call.
3. Implement the corresponding logic to process incoming requests and yield results.

Permissibility

ISC

Recognition

• PokeAPI: Source of the core Pokémon datasets
• Model Context Protocol: Provider of the uniform interface standard

---

This repository serves as a functional demonstration of constructing bespoke MCP servers designed to augment AI assistants with specialized, domain-specific knowledge and operational capacities. WIKIPEDIA: XMLHttpRequest (XHR) is an API in the form of a JavaScript object whose methods transmit HTTP requests from a web browser to a web server. The methods allow a browser-based application to send requests to the server after page loading is complete, and receive information back. XMLHttpRequest is a component of Ajax programming. Prior to Ajax, hyperlinks and form submissions were the primary mechanisms for interacting with the server, often replacing the current page with another one.

== History == The concept behind XMLHttpRequest was conceived in 2000 by the developers of Microsoft Outlook. The concept was then implemented within the Internet Explorer 5 browser (1999). However, the original syntax did not use the XMLHttpRequest identifier. Instead, the developers used the identifiers ActiveXObject("Msxml2.XMLHTTP") and ActiveXObject("Microsoft.XMLHTTP"). As of Internet Explorer 7 (2006), all browsers support the XMLHttpRequest identifier. The XMLHttpRequest identifier is now the de facto standard in all the major browsers, including Mozilla's Gecko layout engine (2002), Safari 1.2 (2004) and Opera 8.0 (2005).

=== Standards === The World Wide Web Consortium (W3C) published a Working Draft specification for the XMLHttpRequest object on April 5, 2006. On February 25, 2008, the W3C published the Working Draft Level 2 specification. Level 2 added methods to monitor event progress, allow cross-site requests, and handle byte streams. At the end of 2011, the Level 2 specification was absorbed into the original specification. At the end of 2012, the WHATWG took over development and maintains a living document using Web IDL.

== Usage == Generally, sending a request with XMLHttpRequest has several programming steps.

Create an XMLHttpRequest object by calling a constructor: Call the "open" method to specify the request type, identify the relevant resource, and select synchronous or asynchronous operation: For an asynchronous request, set a listener that will be notified when the request's state changes: Initiate the request by calling the "send" method: Respond to state changes in the event listener. If the server sends response data, by default it is captured in the "responseText" property. When the object stops processing the response, it changes to state 4, the "done" state. Aside from these general steps, XMLHttpRequest has many options to control how the request is sent and how the response is processed. Custom header fields can be added to the request to indicate how the server should fulfill it, and data can be uploaded to the server by providing it in the "send" call. The response can be parsed from the JSON format into a readily usable JavaScript object, or processed gradually as it arrives rather than waiting for the entire text. The request can be aborted prematurely or set to fail if not completed in a specified amount of time.

== Cross-domain requests ==

In the early development of the World Wide Web, it was found possible to brea