# mcp-server ![NPM Version](https://img.shields.io/npm/v/%40agentico%2Fmcp-server)

> [!IMPORTANT]
> This project has evolved into [HAPI MCP](https://www.npmjs.com/settings/mcp-com-ai/packages). We started exploring MCP in November 2024 and quickly realized that MCP is most valuable as a contract between AI clients and existing services, not as a custom server layer that duplicates backend logic.
>
> That insight led us to create the HAPI MCP approach: expose your existing APIs through OAS/Swagger or Arazzo specs, and let HAPI MCP handle the rest.
>
> We recommend using the new package and following updates in the [MCP.com.ai GitHub repository](https://github.com/mcp-com-ai/hapimcp).

This project is the early version of that journey: a simple MCP server that helped us learn, prototype, and validate the approach.

Evolution of the project:

[MCP Server](https://github.com/la-rebelion/mcp-server) -> [HAPI MCP Server](https://github.com/la-rebelion/hapimcp) (by La Rebelion Labs) -> [HAPI MCP](https://github.com/mcp-com-ai/hapimcp) (by MCP.com.ai)

Today, the recommended workflow is to run an MCP server with the `hapi` CLI and your OAS/Swagger or Arazzo specification.

```sh
hapi serve my-server --headless --specs https://your.specs.url --url https://your.backend.url
```

![MCP Server](https://mcp.com.ai/img/logo.svg)

---

MCP Server is a simple server that implements the Model Context Protocol (MCP) to provide a **simpler API** to interact with the Model Context Protocol. 

## Why Use This Server?

In "[La Rebelion](https://rebelion.la)" we are working on a set of tools and services to simplify processes and workflows for a better and more efficient developer experience. This server is part of a set of tools.

MCP is amazing, but it can be a bit confusing to get started. We have create a **[facade](https://refactoring.guru/design-patterns/facade)** to simplify the process of creating a server that implements the Model Context Protocol. The pattern is simple, you just need to create the `tools` with your own logic, register the tools and start the server.

## Steps to Create a New Server

In the future we will provide a CLI to create a new server similar to [MCP create server](https://www.npmjs.com/package/@modelcontextprotocol/create-server), but for now you can follow the steps below based on the [official documentation to create a server](https://modelcontextprotocol.io/quickstart/server).

```bash
mkdir -p my-server/src
cd my-server/
yarn init -y
yarn add @modelcontextprotocol/sdk zod zod-to-json-schema
yarn add -D @types/node typescript
# Here lies the magic
yarn add @agentico/mcp-server
```

You need to update the `package.json` file and create a `tsconfig.json` file.

## Getting Started

Implement your tools with your custom logic, and register them in the MCPServer. Here is an example of a simple `echo` tool:

```typescript
import { Tool, ToolSchema } from "@agentico/mcp-server";

export class EchoTool extends Tool {
  toolSchema: ToolSchema = { 
    name: "echo",
    description: "Echoes the input message",
    schema: { // the schema for the parameters needed by the tool
      type: "object",
      properties: {
        message: { type: "string" },
      },
      required: ["message"],
    },
  };

  /**
   * Your logic here, implement the execute method to define the tool behavior
   * @param input The input message - use the schema to define the input type
   * @returns In the example, we are echoing the message
   */
  async execute(input: any): Promise<any> {
    // This is a simple echo tool demo, nothing fancy, just echoing the message
    return Promise.resolve({
      content: [
        {
          type: "text",
          text: `${input.message}` 
        }
      ]
      });
  }
}
```

Create an `index.ts` file with the following content:

```typescript
#!/usr/bin/env node
import { MCPServer } from '@agentico/mcp-server'
import { EchoTool } from "./tools/EchoTool.js";

const myServer = new MCPServer('My MCP Server', '1.0.0');

async function main() {
  // Register tools
  myServer.registerTool("echo", EchoTool);
  await myServer.run();
}

main().catch((error) => {
  console.error("Server error:", error);
  process.exit(1);
});
```

That's it! You have created a simple server that implements the Model Context Protocol. Test it with [Claude Desktop](https://claude.ai/download) or any other client that supports MCP.

Build the project with the following command:

```bash
yarn build
```

You can start the server, but has no logic yet, you can test it with the following command:

```bash
yarn start
# or
node build/index.js
```

That's it, start creating your own tools and services to simplify your workflows and processes.

Go Rebels! ✊🏻

## UML Diagram

![UML Diagram](./mcp-server.png)

* **MCPServer**: Registers the tools that will be used by the server.
* **Tool**: Base class for all tools, containing common properties and methods. `execute` is the method that will be called when the tool is invoked, implement your logic here.
* **EchoTool**: Specific implementation of a tool, extending the Tool class and defining its own schema and initialization logic.
* **EchoSchema**: Defines the structure of the input for the EchoTool.
* **EchoInput**: Type definition for the input based on the schema.

This pattern allows for a flexible and extensible way to manage and implement tools using the MCPServer and Tool classes.

## Support Us

If you find this helpful, please consider supporting us by giving a star to this repository, by contributing to the project or by becoming a sponsor.

You can find more information on how to support us at [La Rebelion GitHub Sponsors](https://github.com/sponsors/la-rebelion). Also, [buying us a coffee](https://buymeacoffee.com/larebelion), [PayPal](https://www.paypal.com/donate?hosted_button_id=7CV28AHGL9ZZY) is a great way to support us or purchasing ["La Rebelion" merch](https://go.rebelion.la/merch).

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.