ServeMyAPI

1# ServeMyAPI
2 
3[![smithery badge](https://smithery.ai/badge/@Jktfe/servemyapi)](https://smithery.ai/server/@Jktfe/servemyapi)
4 
5A personal MCP (Model Context Protocol) server for securely storing and accessing API keys across projects using the macOS Keychain.
6 
7> **IMPORTANT**: ServeMyAPI is a macOS-specific tool that relies on the macOS Keychain for secure storage. It is not compatible with Windows or Linux operating systems. See the security notes section for more details.
8 
9## Overview
10 
11ServeMyAPI allows you to store API keys securely in the macOS Keychain and access them through a consistent MCP interface. This makes it easy to:
12 
13- Store API keys securely (they're never visible in .env files or config files)
14- Access the same keys across multiple projects
15- Use natural language to store and retrieve keys (when used with LLMs like Claude)
16- Provide keys directly to your AI assistant when it needs to access services
17 
18## Why ServeMyAPI over .ENV Files?
19 
20Using ServeMyAPI instead of traditional .ENV files solves several common problems:
21 
221. **GitHub Security Conflicts**: 
23   - .ENV files need to be excluded from Git repositories for security (via .gitignore)
24   - This creates a "hidden context" problem where important configuration is invisible to collaborators and LLMs
25   - New developers often struggle with setting up the correct environment variables
26 
272. **LLM Integration Challenges**:
28   - LLMs like Claude can't directly access your .ENV files due to security constraints
29   - When LLMs need API keys to complete tasks, you often need manual workarounds
30   - ServeMyAPI lets your AI assistant request keys through natural language
31 
323. **Cross-Project Consistency**:
33   - With .ENV files, you typically need to duplicate API keys across multiple projects
34   - When keys change, you need to update multiple files
35   - ServeMyAPI provides a central storage location accessible from any project
36 
37This approach gives you the best of both worlds: secure storage of sensitive credentials without sacrificing visibility and accessibility for your AI tools.
38 
39## Features
40 
41- Secure storage of API keys in the macOS Keychain
42- Simple MCP tools for storing, retrieving, listing, and deleting keys
43- Convenient CLI interface for terminal-based key management
44- Support for both stdio and HTTP/SSE transports
45- Compatible with any MCP client (Claude Desktop, etc.)
46 
47## Installation
48 
49```bash
50# Clone the repository
51git clone https://github.com/yourusername/servemyapi.git
52cd servemyapi
53 
54# Install dependencies
55npm install
56 
57# Build the project
58npm run build
59```
60 
61## Usage
62 
63### CLI Interface
64 
65ServeMyAPI comes with a command-line interface for quick key management directly from your terminal:
66 
67```bash
68# Install the CLI globally
69npm run build
70npm link
71 
72# List all stored API keys
73api-key list
74 
75# Get a specific API key
76api-key get github_token
77 
78# Store a new API key
79api-key store github_token ghp_123456789abcdefg
80 
81# Delete an API key
82api-key delete github_token
83 
84# Display help
85api-key help
86```
87 
88### Running as a stdio server
89 
90This is the simplest way to use ServeMyAPI as an MCP server, especially when working with Claude Desktop:
91 
92```bash
93npm start
94```
95 
96### Running as an HTTP server
97 
98For applications that require HTTP access:
99 
100```bash
101node dist/server.js
102```
103 
104This will start the server on port 3000 (or the port specified in the PORT environment variable).
105 
106### Using Smithery
107 
108ServeMyAPI is available as a hosted service on [Smithery](https://smithery.ai/server/@Jktfe/servemyapi).
109 
110```javascript
111import { createTransport } from "@smithery/sdk/transport.js"
112 
113const transport = createTransport("https://server.smithery.ai/@Jktfe/servemyapi")
114 
115// Create MCP client
116import { Client } from "@modelcontextprotocol/sdk/client/index.js"
117 
118const client = new Client({
119	name: "Test client",
120	version: "1.0.0"
121})
122await client.connect(transport)
123 
124// Use the server tools with your LLM application
125const tools = await client.listTools()
126console.log(`Available tools: ${tools.map(t => t.name).join(", ")}`)
127```
128 
129For more details, see the [Smithery API documentation](https://smithery.ai/server/@Jktfe/servemyapi/api).
130 
131### Configuring MCP Clients
132 
133ServeMyAPI works with any MCP-compatible client. Example configuration files are provided in the `examples` directory.
134 
135#### Claude Desktop
136 
137To use ServeMyAPI with Claude Desktop:
138 
1391. Locate or create the Claude Desktop configuration file:
140   - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
141   - **Windows**: `%AppData%\Claude\claude_desktop_config.json`
142 
1432. Add ServeMyAPI to the `mcpServers` section (you can copy from `examples/claude_desktop_config.json`):
144   ```json
145   {
146     "mcpServers": {
147       "serveMyAPI": {
148         "command": "node",
149         "args": [
150           "/ABSOLUTE/PATH/TO/servemyapi/dist/index.js"
151         ]
152       }
153     }
154   }
155   ```
156 
1573. Replace `/ABSOLUTE/PATH/TO/servemyapi` with the actual path to your ServeMyAPI installation.
1584. Restart Claude Desktop.
159 
160#### Windsurf
161 
162To use ServeMyAPI with Windsurf:
163 
1641. Open Windsurf editor and navigate to Settings
1652. Add ServeMyAPI to your MCP server configuration using the example in `examples/windsurf_config.json`
1663. Adapt the paths to your local installation
167 
168## MCP Tools
169 
170ServeMyAPI exposes the following tools:
171 
172### store-api-key
173 
174Store an API key in the keychain.
175 
176Parameters:
177- `name`: The name/identifier for the API key
178- `key`: The API key to store
179 
180Example (from Claude):
181```
182Using serveMyAPI, store my API key ABC123XYZ as "OpenAI API Key"
183```
184 
185### get-api-key
186 
187Retrieve an API key from the keychain.
188 
189Parameters:
190- `name`: The name/identifier of the API key to retrieve
191 
192Example (from Claude):
193```
194Using serveMyAPI, get the API key named "OpenAI API Key"
195```
196 
197### delete-api-key
198 
199Delete an API key from the keychain.
200 
201Parameters:
202- `name`: The name/identifier of the API key to delete
203 
204Example (from Claude):
205```
206Using serveMyAPI, delete the API key named "OpenAI API Key"
207```
208 
209### list-api-keys
210 
211List all stored API keys.
212 
213No parameters required.
214 
215Example (from Claude):
216```
217Using serveMyAPI, list all my stored API keys
218```
219 
220## Security Notes
221 
222- All API keys are stored securely in the macOS Keychain
223- Keys are only accessible to the current user
224- The keychain requires authentication for access
225- No keys are stored in plaintext or logged anywhere
226 
227## Roadmap
228 
229Future plans for ServeMyAPI include:
230 
231- **Code Scanner Tool**: A tool that automatically scans your codebase for API endpoints, sensitive URLs, and environment variables, then suggests names to store them in the Keychain. This would allow developers to continue using .ENV files in their regular workflow while ensuring credentials are also available to LLMs and other tools when needed.
232 
233- **Cross-Platform Support**: Investigating secure credential storage options for Windows and Linux to make ServeMyAPI more widely accessible.
234 
235- **Integration with Popular Frameworks**: Providing easy integration with frameworks like Next.js, Express, and others.
236 
237- **UI for Key Management**: A simple web interface for managing your stored API keys directly.
238 
239Feel free to suggest additional features or contribute to the roadmap by opening an issue or pull request.
240 
241## Development
242 
243```bash
244# Run in development mode with hot reload
245npm run dev
246 
247# Use the CLI during development
248npm run cli list
249 
250# Lint the code
251npm run lint
252 
253# Build for production
254npm run build
255```
256 
257## License
258 
259MIT