Skip to content
Back to search

furi

CLI & API for MCP management

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ashwwwin--furi/badge.svg)](/listings/ashwwwin--furi)

HTML

<a href="/listings/ashwwwin--furi"><img src="/api/listings/ashwwwin--furi/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

To install Furi, you can use the following command:

curl -fsSL https://furi.so/install | bash

Verify the installation by running:

furi

_Furikake uses Bun under the hood, the install script will install Bun if it is not already installed._

Upgrade Furi

To upgrade Furi to the latest version, run:

furi upgrade

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 407 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # furi
  2. furi is an easy to use, CLI & API for MCP management.
  3. - Download MCP servers [from GitHub]
  4. - Smithery.yaml detection (or auto detects/handles execution)
  5. - Fully featured CLI [nanospinners, readability]
  6. - Typescript & Javascript MCP's are supported
  7. - Python based MCP's are a key roadmap item (and will be supported)
  8. - HTTP API Routes (uses Bun http, stdio to http, clear and standard routes)
  9. - Customizable port and visibility of sudo routes
  10. - View all running MCPs + logs for each process
  11. - Process state management [with PM2](https://pm2.keymetrics.io/)
  12. - Built with [Bun](https://bun.sh/) and [Typescript](https://www.typescriptlang.org/)
  13. - is good with rice
  14. ## Installation (macOS/Linux)
  15. To install Furi, you can use the following command:
  16. ```bash
  17. curl -fsSL https://furi.so/install | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 22 on GitHub
  18. ```
  19. Verify the installation by running:
  20. ```bash
  21. furi
  22. ```
  23. _Furikake uses Bun under the hood, the install script will install Bun if it is not already installed._
  24. ### Upgrade Furi
  25. To upgrade Furi to the latest version, run:
  26. ```bash
  27. furi upgrade
  28. ```
  29. ## How to use
  30. ### Manage MCPs
  31. Furikake works with any public github repo as follows:
  32. ```bash
  33. furi add <author/repo>
  34. ```
  35. _eg. furi add smithery-ai/mcp-fetch_
  36. You can also rename an MCP by using the `rename` command, please note this will restart the MCP if it is running.
  37. ```bash
  38. furi rename <old-name> <new-name>
  39. ```
  40. _eg. furi rename smithery-ai/mcp-fetch mcp-fetch_
  41. #### Delete an MCP
  42. ```bash
  43. furi remove <mcpName>
  44. ```
  45. _eg. furi remove mcp-fetch_
  46. #### List installed MCPs
  47. Show all installed MCPs
  48. ```bash
  49. furi list
  50. ```
  51. #### Start an MCP
  52. ```bash
  53. furi start <mcpName> -e '{"name1":"value1", "name2":"value2"}'
  54. ```
  55. -e env is optional and dependant on the MCP server being called
  56. Ensure you pass a valid JSON object to the `-e` flag.
  57. Once you start a server with the `-e` flag, it will be saved to the config file and re-used when using the server again.
  58. In order to view the env variables required for an MCP, use:
  59. ```bash
  60. furi env <mcpName>
  61. ```
  62. You can get a list of all the tools available (with details) of any MCP by using:
  63. ```bash
  64. furi tools <mcpName>
  65. ```
  66. then you can call the tool with:
  67. #### Call a tool
  68. ```bash
  69. furi call <mcpName> <toolName> '{"param1":"value1", "param2":"value2"}'
  70. ```
  71. _Parameters must be a valid JSON string enclosed in single quotes_
  72. #### Stop an MCP
  73. ```bash
  74. furi stop <mcpName>
  75. ```
  76. #### Restart an MCP
  77. ```bash
  78. furi restart <mcpName>
  79. ```
  80. #### Get the status of all running MCPs
  81. This will show you the status of all running MCPs.
  82. ```bash
  83. furi status
  84. ```
  85. If you want to get the logs a specific MCP, you can use:
  86. ```bash
  87. furi status <mcpName>
  88. ```
  89. _to view more output lines, use `-l <lines>`_
  90. #### Configuration storage
  91. All installed MCPs, your configuration and logs are stored in the `.furikake` directory which can be located by running:
  92. ```bash
  93. furi where
  94. ```
  95. ## Using the MCP Aggregator
  96. You can use Furikake with any MCP client such as Cursor via the MCP Aggregator.
  97. Furi collects tools from all running MCPs and exposes them through an SSE endpoint that your app or mcp client can subscribe to. The aggregator automatically builds the list of tools from all running MCPs and listens for new tools as MCPs are started and stopped.
  98. ### For MCP Clients that support SSE
  99. To start the aggregator server:
  100. ```bash
  101. furi meta start
  102. ```
  103. _This will also show you the endpoint your MCP client needs to subscribe to_
  104. ### For MCP Clients that only support stdio
  105. Some MCP clients don't support SSE transport and require stdio connections. For these clients, use:
  106. ```bash
  107. furi connect
  108. ```
  109. This starts the aggregator server directly in stdio mode, allowing MCP clients to connect via stdin/stdout. The server will aggregate all tools from your running MCPs and make them available through the stdio transport.
  110. **Important**: This command provides JSON-only output to comply with MCP protocol requirements. All logging is suppressed to ensure clean communication with MCP clients.
  111. _Note: Unlike `furi meta start`, this command runs in the foreground and maintains the connection directly._
  112. You can specify a custom port:
  113. ```bash
  114. furi meta start -p 9338
  115. ```
  116. _If you don't pass a port, it will default to 9338_
  117. To stop the aggregator:
  118. ```bash
  119. furi meta stop
  120. ```
  121. To restart the aggregator (preserving port settings):
  122. ```bash
  123. furi meta restart
  124. ```
  125. To check the status of the aggregator server:
  126. ```bash
  127. furi meta status
  128. ```
  129. _To view more output lines, use `-l <lines>`_
  130. ## Using the HTTP API
  131. - Any MCP that is running, will automatically have an http route.
  132. - Turning an MCP on/off can only be done via the cli.
  133. To access your MCP's via http, you can turn on the proxy via:
  134. ```bash
  135. furi http start
  136. ```
  137. In order to pass a port, you can use the `http start -p <port>` flag.
  138. ```bash
  139. furi http start -p 9339
  140. ```
  141. _If you don't pass a port, it will default to 9339_
  142. To turn off the route, you can use:
  143. ```bash
  144. furi http stop
  145. ```
  146. ### HTTP API Reference
  147. The Furikake HTTP API is divided into **public routes** and **sudo routes**. Public routes are accessible by default, while sudo routes must be explicitly enabled. With sudo routes, you can actively manage packages and instances via the HTTP API.
  148. If you want to secure your API, you can set the `HTTP_AUTH_TOKEN` environment variable.
  149. ```bash
  150. export HTTP_AUTH_TOKEN=your-secret-token
  151. ```
  152. or in your `.env` file:
  153. ```bash
  154. HTTP_AUTH_TOKEN=your-secret-token
  155. ```
  156. #### GitHub Rate Limiting
  157. To avoid GitHub API rate limiting when installing packages, you can provide a GitHub personal access token:
  158. ```bash
  159. export GITHUB_KEY=your-github-token
  160. ```
  161. or in your `.env` file:
  162. ```bash
  163. GITHUB_KEY=your-github-token
  164. ```
  165. This increases your rate limit from 60 requests/hour to 5,000 requests/hour. You can create a personal access token at [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).
  166. #### API Response Format
  167. All API endpoints follow a standardized JSON response format:
  168. - **Success responses**:
  169. ```json
  170. {
  171. "success": true,
  172. "data": {"The response varies by endpoint"}
  173. }
  174. ```
  175. - **Error responses**:
  176. ```json
  177. {
  178. "success": false,
  179. "message": "Descriptive error message"
  180. }
  181. ```
  182. #### HTTP Methods
  183. - **POST** - Used only for `/mcpName/call/toolName` and `/mcpName/start` endpoints
  184. - **GET** - Used for all other endpoints
  185. ### Public Routes
  186. | Endpoint | Method | Description | Parameters | Response Format |
  187. | ---------------------------- | ------ | ---------------------------------------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
  188. | `/list` | GET | List running MCPs | `?all=true` (optional) to show all installed MCPs | `{"success": true, "data": ["mcpName1", "mcpName2"]}` |
  189. | `/tools` | GET | List all available tools from all running MCPs | None | `{"success": true, "data": [{"name": "toolName", "description": "Tool description", "inputSchema": {...}, "mcpName": "mcpName"}]}` |
  190. | `/<mcpName>/tools` | GET | List tools for a specific MCP | None | `{"success": true, "data": [{"name": "toolName", "description": "Tool description", "inputSchema": {...}}]}` |
  191. | `/<mcpName>/call/<toolName>` | POST | Call a tool on an MCP | Tool parameters as JSON in request body | `{"success": true, "data": {/* Tool-specific response */}}` |
  192. #### Example Usage:
  193. List running MCPs:
  194. ```bash
  195. curl http://localhost:9339/list
  196. ```
  197. To view all available tools for all online MCPs, you can use:
  198. ```bash
  199. curl "http://localhost:9339/list"
  200. ```
  201. List tools for all online MCPs:
  202. ```bash
  203. curl http://localhost:9339/tools
  204. ```
  205. List tools for a specific MCP:
  206. ```bash
  207. curl http://localhost:9339/<mcpName>/tools
  208. ```
  209. Call a tool:
  210. ```bash
  211. curl -X POST http://localhost:9339/<mcpName>/call/<toolName> -d '{"data1":"value1", "data2":"value2"}'
  212. ```
  213. ### Sudo Routes
  214. To enable sudo routes that allow API management of MCPs:
  215. ```bash
  216. furi http start --sudo
  217. ```
  218. | Endpoint | Method | Description | Parameters | Response Format |
  219. | ---------------------- | ------ | -------------------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
  220. | `/status` | GET | Get status of all MCPs (running and stopped) | None | `{"success": true, "data": [{"name": "mcpName", "pid": "12345", "status": "online", "cpu": "0%", "memory": "10MB", "uptime": "2h"}]}` |
  221. | `/add/<author>/<repo>` | GET | Install MCP from GitHub | None | `{"success": true, "data": {"installed": true, "message": "Successfully installed"}}` |
  222. | `/<mcpName>/status` | GET | Get status of a specific MCP | `?lines=10` (optional) to control log lines | `{"success": true, "data": {"name": "mcpName", "pid": "12345", "status": "online", "logs": ["log line 1", "log line 2"]}}` |
  223. | `/<mcpName>/restart` | GET | Restart a specific MCP | None | `{"success": true, "data": {"restarted": true}}` |
  224. | `/<mcpName>/start` | POST | Start a specific MCP | Environment variables as JSON in request body | `{"success": true, "data": {"started": true}}` |
  225. | `/<mcpName>/stop` | GET | Stop a specific MCP | None | `{"success": true, "data": {"stopped": true}}` |
  226. | `/<mcpName>/rename` | GET | Rename a specific MCP | `?newName=<newName>` (required) | `{"success": true, "message": "Renamed from oldName to newName"}` or `{"success": false, "message": "Error message"}` |
  227. | `/<mcpName>/remove` | GET | Delete a specific MCP | None | `{"success": true, "data": {"removed": true}}` |
  228. | `/<mcpName>/env` | GET | Get environment variables for a specific MCP | None | `{"success": true, "data": {"variables": ["key1", "key2"]}}` |
  229. #### Example Usage:
  230. Get status of all MCPs:
  231. ```bash
  232. curl http://localhost:9339/status
  233. ```
  234. Install an MCP:
  235. ```bash
  236. curl http://localhost:9339/add/<author>/<repo>
  237. ```
  238. Get status and logs of a specific MCP:
  239. ```bash
  240. curl "http://localhost:9339/<mcpName>/status?lines=20"
  241. ```
  242. Start an MCP with environment variables:
  243. ```bash
  244. curl -X POST http://localhost:9339/<mcpName>/start -d '{"API_KEY":"your-api-key-here"}'
  245. ```
  246. Restart an MCP:
  247. ```bash
  248. curl http://localhost:9339/<mcpName>/restart
  249. ```
  250. Stop an MCP:
  251. ```bash
  252. curl http://localhost:9339/<mcpName>/stop
  253. ```
  254. Rename an MCP:
  255. ```bash
  256. curl "http://localhost:9339/<mcpName>/rename?newName=<newName>"
  257. ```
  258. Remove an MCP:
  259. ```bash
  260. curl http://localhost:9339/<mcpName>/remove
  261. ```
  262. If you face any issues with the HTTP API server, you can use the `furi http status` to debug.
  263. ## Closing notes
  264. If you've made it this far, I hope you find Furikake useful and time saving. I built this for fun as a way for me to work with MCP's more hands on. If you wish to contribute, feel free to open an issue or a pull request. I will merge after I check out your changes.
  265. If you think this is a good idea, please star the repo.
  266. Thanks for checking out Furikake.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.