# AI Sticky Notes — MCP Server

A minimal [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) server that gives an AI assistant simple persistent "sticky notes" — the ability to save short notes to a local file and read them back later, across conversations.

## What it exposes

The server (`server.py`) is built with `fastmcp` / `mcp` and exposes:

### Tools
| Tool | Description |
|---|---|
| `add_note(message: str)` | Appends a new note to the sticky note file. Returns a confirmation string once saved. |
| `read_notes()` | Reads and returns all saved notes as a single string. Returns `"No notes yet."` if the file is empty. |

### Resources
| Resource | Description |
|---|---|
| `notes://latest` | Returns just the most recently added note. Returns `"No notes yet."` if there are none. |

### Prompts
| Prompt | Description |
|---|---|
| `note_summary_prompt()` | Generates a prompt asking the AI to summarize all current notes. Returns a message noting there's nothing to summarize if the notes file is empty. |

Notes are stored in a plain text file, `notes.txt`, in the same directory as `server.py`, with each note on its own line. The file is created automatically on first use.

## Project structure

```
MCPSerrver/
├── server.py          # The MCP server: tools, resource, and prompt definitions
├── client.py           # A standalone test client that exercises the server over stdio
├── notes.txt            # Generated at runtime — stores the notes
├── pyproject.toml        # Project metadata and dependencies
├── uv.lock                # Locked dependency versions
└── .python-version        # Pinned Python version for the project
```

## Requirements

- Python **3.13+**
- Dependencies (see `pyproject.toml`):
  - `fastmcp>=2.14.1`
  - `mcp[cli]>=2.0.0`

## Setup

Using [`uv`](https://docs.astral.sh/uv/) (recommended, uses the committed lockfile):
```bash
git clone git@github.com:pallikop/MCPSerrver.git
cd MCPSerrver
uv sync
```

Or with `pip`:
```bash
pip install fastmcp mcp[cli]
```

## Running the server

The server communicates over stdio, so it's designed to be launched by an MCP-compatible client (like Claude Desktop, Claude Code, or the included test client) rather than run standalone for interactive use:

```bash
python server.py
```

## Testing with the included client

`client.py` is a small standalone script that connects to `server.py` over stdio and exercises every tool, resource, and prompt the server exposes:

```bash
python client.py
```

It will:
1. List all available tools, resources, and prompts
2. Call `add_note` with a test message
3. Call `read_notes` to confirm it was saved
4. Read the `notes://latest` resource
5. Fetch the `note_summary_prompt` prompt

## Connecting to an MCP client

To use this server with an MCP-compatible client (e.g. Claude Desktop), point the client's MCP server config at `server.py`, for example:

```json
{
  "mcpServers": {
    "ai-sticky-notes": {
      "command": "python",
      "args": ["/path/to/MCPSerrver/server.py"]
    }
  }
}
```

## Notes on the current implementation

- Notes are stored unencrypted in a local plain-text file (`notes.txt`) — there's no authentication or multi-user separation.
- `add_note` always appends; there's currently no way to delete or edit an individual note through the exposed tools.
- The notes file path is resolved relative to `server.py`'s own location, so it will always read/write in the same directory regardless of where the server is launched from.