Skip to content
Back to search

Noryx

A Python MCP server for AI tools, knowledge management, and secure workspace operations

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/tarikh792--noryx/badge.svg)](/listings/tarikh792--noryx)

HTML

<a href="/listings/tarikh792--noryx"><img src="/api/listings/tarikh792--noryx/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.

Prerequisites

- Python 3.11 - pip - Node.js and npm (optional, for MCP Inspector)

1. Clone the Repository

git clone https://github.com/Tarikh792/Noryx.git
cd Noryx

2. Create a Virtual Environment

python -m venv .venv

Activate it on Windows PowerShell:

.\.venv\Scripts\Activate.ps1

For macOS or Linux:

source .venv/bin/activate

3. Install Dependencies

python -m pip install -r requirements.txt

The project uses MCP SDK 1.x because its implementation relies on the `FastMCP` interface.

mcp[cli]>=1.0,<2

4. Test Notes Management

python notes.py

This creates a sample note and verifies that saving, reading, listing, and keyword searching work correctly.

5. Run the MCP Client Integration Test

python test_client.py

The client automatically starts the server, initializes an MCP session, discovers the available tools, and executes test operations.

Expected tool names:

server_status
create_note
get_note
get_all_notes
find_notes

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 · 324 lines
  1. # 🟣 Noryx — MCP Knowledge Management Server
  2. **A modular Model Context Protocol server for connecting AI applications to structured knowledge and productivity tools.**
  3. Noryx is a Python-based MCP server that enables compatible AI clients to create, read, list, and search notes through a standardized tool interface.
  4. Built with the official MCP Python SDK, Noryx demonstrates practical MCP server development, tool registration, local data persistence, and client-server communication.
  5. The project includes a custom Python MCP client and has been tested using MCP Inspector.
  6. ## ✨ Features
  7. - **MCP Tool Integration** — Exposes Python functions as discoverable MCP tools.
  8. - **Notes Management** — Create, update, retrieve, and list notes.
  9. - **Knowledge Search** — Find notes using keyword-based search across titles and content.
  10. - **Local Persistence** — Store notes in JSON format.
  11. - **Client-Server Communication** — Supports the MCP standard input/output (stdio) transport.
  12. - **Tool Discovery** — Compatible MCP clients can discover available tools.
  13. - **MCP Inspector Integration** — Graphically inspect and execute tools.
  14. - **Custom MCP Client** — Includes a Python client for integration testing.
  15. - **Input Validation** — Rejects empty note titles and content.
  16. ## 🛠️ Available MCP Tools
  17. | Tool | Description |
  18. |---|---|
  19. | `server_status` | Check server status |
  20. | `create_note` | Create or update a note |
  21. | `get_note` | Retrieve a note by title |
  22. | `get_all_notes` | List all saved note titles |
  23. | `find_notes` | Search notes by keyword |
  24. All five tools have been registered successfully. The note creation and search functions have also been tested through MCP client communication.
  25. ## 🧠 How Noryx Works
  26. Noryx acts as an intermediary between compatible AI applications and a local knowledge store.
  27. ```text
  28. MCP-Compatible AI Client
  29. |
  30. |
  31. MCP Protocol
  32. (stdio)
  33. |
  34. v
  35. +----------------------+
  36. | NORYX SERVER |
  37. | Python MCP |
  38. +----------------------+
  39. |
  40. MCP Tool Registry
  41. |
  42. +------------+------------+
  43. | | |
  44. v v v
  45. Create Note Read Note Search Notes
  46. | | |
  47. +------------+------------+
  48. |
  49. v
  50. notes.py
  51. |
  52. v
  53. notes.json
  54. Local JSON Storage
  55. ```
  56. The server uses the MCP Python SDK to expose Python functions as tools. Client requests are routed through the MCP protocol and handled by the corresponding notes-management functions.
  57. ## 💻 Technology Stack
  58. | Component | Technology |
  59. |---|---|
  60. | Programming Language | Python 3.11 |
  61. | Protocol | Model Context Protocol (MCP) |
  62. | SDK | Official MCP Python SDK 1.x |
  63. | Server Framework | FastMCP |
  64. | Transport | stdio |
  65. | Storage | JSON |
  66. | Integration Testing | Python MCP Client |
  67. | Graphical Testing | MCP Inspector |
  68. ## 📁 Project Structure
  69. ```text
  70. Noryx/
  71. ├── server.py
  72. ├── notes.py
  73. ├── test_client.py
  74. ├── requirements.txt
  75. ├── README.md
  76. ├── .gitignore
  77. └── notes.json # Generated locally, not committed
  78. ```
  79. ### Core Components
  80. **`server.py`**
  81. Initializes the MCP server and registers all five tools.
  82. **`notes.py`**
  83. Implements note creation, retrieval, listing, searching, and local JSON persistence.
  84. **`test_client.py`**
  85. Connects to the server through stdio and tests tool discovery and execution.
  86. **`requirements.txt`**
  87. Defines the compatible MCP SDK dependency.
  88. ## 🚀 Getting Started
  89. ### Prerequisites
  90. - Python 3.11
  91. - pip
  92. - Node.js and npm (optional, for MCP Inspector)
  93. ### 1. Clone the Repository
  94. ```bash
  95. git clone https://github.com/Tarikh792/Noryx.git
  96. cd Noryx
  97. ```
  98. ### 2. Create a Virtual Environment
  99. ```bash
  100. python -m venv .venv
  101. ```
  102. Activate it on Windows PowerShell:
  103. ```powershell
  104. .\.venv\Scripts\Activate.ps1
  105. ```
  106. For macOS or Linux:
  107. ```bash
  108. source .venv/bin/activate
  109. ```
  110. ### 3. Install Dependencies
  111. ```bash
  112. python -m pip install -r requirements.txt
  113. ```
  114. The project uses MCP SDK 1.x because its implementation relies on the `FastMCP` interface.
  115. ```text
  116. mcp[cli]>=1.0,<2
  117. ```
  118. ### 4. Test Notes Management
  119. ```bash
  120. python notes.py
  121. ```
  122. This creates a sample note and verifies that saving, reading, listing, and keyword searching work correctly.
  123. ### 5. Run the MCP Client Integration Test
  124. ```bash
  125. python test_client.py
  126. ```
  127. The client automatically starts the server, initializes an MCP session, discovers the available tools, and executes test operations.
  128. Expected tool names:
  129. ```text
  130. server_status
  131. create_note
  132. get_note
  133. get_all_notes
  134. find_notes
  135. ```
  136. ## 🔌 Testing with MCP Inspector
  137. MCP Inspector provides a graphical interface for testing MCP servers.
  138. Start it with:
  139. ```bash
  140. npx @modelcontextprotocol/inspector
  141. ```
  142. Configure the server with:
  143. | Field | Value |
  144. |---|---|
  145. | Server Name | Noryx |
  146. | Transport | STDIO |
  147. | Command | Path to your virtual environment's Python executable |
  148. | Arguments | Absolute path to `server.py` |
  149. Connect to the server and open the Tools section.
  150. Select `create_note` and use the following example:
  151. **Title:**
  152. ```text
  153. AI Engineering
  154. ```
  155. **Content:**
  156. ```text
  157. Noryx is a Python MCP knowledge management server.
  158. ```
  159. Execute the tool, then use `get_note` or `find_notes` to retrieve the saved information.
  160. ## 🧪 Example MCP Tool Operations
  161. ### Create a Note
  162. **Tool:** `create_note`
  163. ```json
  164. {
  165. "title": "AI Engineering",
  166. "content": "Noryx provides knowledge management through MCP tools."
  167. }
  168. ```
  169. **Expected result:**
  170. ```text
  171. Note 'AI Engineering' saved successfully.
  172. ```
  173. ### Read a Note
  174. **Tool:** `get_note`
  175. ```json
  176. {
  177. "title": "AI Engineering"
  178. }
  179. ```
  180. ### List All Notes
  181. **Tool:** `get_all_notes`
  182. ```json
  183. {}
  184. ```
  185. ### Search Notes
  186. **Tool:** `find_notes`
  187. ```json
  188. {
  189. "query": "knowledge"
  190. }
  191. ```
  192. Returns matching note titles and content.
  193. ## 🔐 Security & Design Decisions
  194. Noryx uses a limited set of predefined tools rather than exposing arbitrary shell commands or unrestricted filesystem operations.
  195. - Notes are stored in a dedicated local JSON file.
  196. - Input validation prevents empty titles and content.
  197. - Tool execution is limited to explicitly registered functions.
  198. - Local note data is excluded from Git version control.
  199. - No external database or paid API key is required.
  200. - MCP communication uses stdio for local client integration.
  201. This version is intended for trusted local development and testing, not as a publicly exposed multi-user service.
  202. ## ⚠️ Current Limitations
  203. Noryx is a Version 1 MCP server.
  204. - Keyword-based search only; semantic vector search is not implemented.
  205. - Notes use their titles as identifiers; duplicate titles overwrite existing content.
  206. - Storage is a single JSON file rather than a database.
  207. - No built-in user authentication or multi-user permissions.
  208. - No version history or recovery for overwritten notes.
  209. - The server currently operates through local stdio transport.
  210. - Integration with a specific AI chat application is not bundled with the project.
  211. ## 🗺️ Future Improvements
  212. - Semantic knowledge retrieval
  213. - SQLite database storage
  214. - Note deletion and version history
  215. - Tag-based organization
  216. - MCP resource templates
  217. - Multi-user authentication
  218. - Remote MCP deployment
  219. - Expanded AI client integrations
  220. ## 🎬 Project Demo
  221. [▶ Watch Noryx Portfolio Demo](./Noryx%20Portfolio%20Demo%20.mp4)
  222. ## 👨‍💻 Author
  223. **Syed Ali Tarikh**
  224. AI Engineering | Generative AI | Agentic Systems
  225. GitHub: [@Tarikh792](https://github.com/Tarikh792)
  226. ---
  227. **Noryx — Knowledge. Connected.**
  228. *Built to explore standardized AI tool integration through the Model Context Protocol.*

Ratings and comments

Sign in to rate this skill.

Sign in

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