open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/timescale-tiger-memory-mcp-server
Description: MCP server to supply a simple memory system
Author: TigerData
Latest version: 0.1.1

# Tiger Memory MCP Server

A simple memory system designed to allow LLMs to store and retrieve information. This provides some focused tools to LLMs via the [Model Context Protocol](https://modelcontextprotocol.io/introduction).

## API

All methods are exposed as MCP tools and REST API endpoints.

## Development

Cloning and running the server locally.

```bash
git clone git@github.com:timescale/tiger-memory-mcp-server.git
```

### Building

Run `npm i` to install dependencies and build the project. Use `npm run watch` to rebuild on changes.

Create a `.env` file based on the `.env.sample` file.

```bash
cp .env.sample .env
```

### Testing

The MCP Inspector is very handy.

```bash
npm run inspector
```

| Field          | Value           |
| -------------- | --------------- |
| Transport Type | `STDIO`         |
| Command        | `node`          |
| Arguments      | `dist/index.js` |

#### Testing in Claude Desktop

Create/edit the file `~/Library/Application Support/Claude/claude_desktop_config.json` to add an entry like the following, making sure to use the absolute path to your local `tiger-memory-mcp-server` project, and real database credentials.

```json
{
  "mcpServers": {
    "tiger-memory": {
      "command": "node",
      "args": [
        "/absolute/path/to/tiger-memory-mcp-server/dist/index.js",
        "stdio"
      ],
      "env": {
        "PGHOST": "x.y.tsdb.cloud.timescale.com",
        "PGDATABASE": "tsdb",
        "PGPORT": "32467",
        "PGUSER": "readonly_mcp_user",
        "PGPASSWORD": "abc123"
      }
    }
  }
}
```

## Deployment

We use a Helm chart to deploy to Kubernetes. See the `chart/` directory for details.

The service is accessible to other services in the cluster via the DNS name `tiger-memory-mcp-server.savannah-system.svc.cluster.local`.

### Database setup

Creating the database user:

```sql
CREATE USER tiger_memory WITH PASSWORD 'secret';
GRANT CREATE ON DATABASE tsdb TO tiger_memory;
```

### Secrets

Run the following to create the necessary sealed secrets. Be sure to fill in the correct values.

```bash
kubectl -n savannah-system create secret generic tiger-memory-mcp-server-database \
  --dry-run=client \
  --from-literal=user="tiger_memory" \
  --from-literal=password="secret" \
  --from-literal=database="tsdb" \
  --from-literal=host="x.y.tsdb.cloud.timescale.com" \
  --from-literal=port="32467" \
  -o yaml | kubeseal -o yaml

# https://logfire-us.pydantic.dev/tigerdata/tigerdata/settings/write-tokens
kubectl -n savannah-system create secret generic tiger-memory-mcp-server-logfire \
  --dry-run=client \
  --from-literal=token="pylf_v1_us_" \
  -o yaml | kubeseal -o yaml

# https://login.tailscale.com/admin/settings/keys
kubectl -n savannah-system create secret generic tiger-memory-mcp-server-tailscale \
  --dry-run=client \
  --from-literal=authkey="tskey-auth-" \
  -o yaml | kubeseal -o yaml
```

Update `./chart/values/dev.yaml` with the output.
npm package: @iflow-mcp/tinyt-todo-mcp
Description: A Model Context Protocol (MCP) server implementation providing persistent task management capabilities for AI assistants.
Latest version: 0.1.0

# Tiny TODO MCP

A Model Context Protocol (MCP) server implementation providing persistent task management capabilities for AI assistants.

## Overview

Tiny TODO MCP is a specialized server that implements the Model Context Protocol (MCP), allowing AI assistants to interact with persistent storage for tasks. This enables AI models to maintain context over time and create and manage tasks beyond their usual context limitations.

## Features

### TODO System

- **Create TODOs**: Store tasks with titles, descriptions, and due dates
- **Update TODOs**: Mark tasks as complete or incomplete
- **Delete TODOs**: Remove tasks from the system
- **Search TODOs**: Find tasks by various criteria including completion status and due dates
- **Task Management**: View upcoming and overdue tasks

### Integration

- Follows the Model Context Protocol standard
- Designed for easy integration with AI assistants
- Provides consistent error handling and responses

## Use Cases

- Extend AI capabilities with persistent task tracking
- Enable AI assistants to track tasks with due dates and completion status
- Support for time-aware task reminders (upcoming and overdue tasks)

## Architecture

Tiny Memory MCP uses a SQLite database for persistent storage, with a clean layered architecture separating:

- Tool interface (MCP protocol implementation)
- Service layer (business logic)
- Repository layer (data access)
- Database layer (storage)

Each tool exposed through the MCP interface provides clear documentation of its capabilities, parameters, and return values.