memos_crud
Perform CRUD operations on a Memos instance (create, read, update, delete memos).
Best use case
memos_crud is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Perform CRUD operations on a Memos instance (create, read, update, delete memos).
Teams using memos_crud should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/memos_crud/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How memos_crud Compares
| Feature / Agent | memos_crud | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Perform CRUD operations on a Memos instance (create, read, update, delete memos).
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Instructions
Use this skill when you need to interact with a Memos server to manage notes/memos.
This skill provides a Ruby CLI wrapper around the Memos REST API.
Always prefer using this CLI over raw `curl` requests to ensure consistent error handling and state management.
## prerequisites
- Ensure the `memos_skill` directory is your working directory or you reference the script path correctly.
- The environment variables in `.env` must be configured (checked automatically by the script).
## Commands
Run the CLI using `ruby scripts/memos_cli.rb <command> [options]`.
All commands return JSON.
### 1. List Memos
Fetch a list of memos. default limit is 50.
```bash
ruby scripts/memos_cli.rb list --page-size 10 --state NORMAL
```
**Options:**
- `--page-size N`: Number of items (default 50).
- `--page-token TOKEN`: For pagination.
- `--state STATE`: `NORMAL` or `ARCHIVED`.
- `--filter "content.contains('keyword')"`: Filter by content.
### 2. Create Memo
Create a new memo.
```bash
ruby scripts/memos_cli.rb create --content "My new memo content" --visibility PRIVATE
```
**Options:**
- `--content "STRING"`: (Required) The content of the memo.
- `--visibility VIS`: `PRIVATE` (default), `PROTECTED`, or `PUBLIC`.
- `--pinned BOOL`: `true` or `false`.
### 3. Get Memo
Get a single memo by details.
```bash
ruby scripts/memos_cli.rb get --memo memos/123
```
**Options:**
- `--memo ID`: The memo ID (e.g., `123` or `memos/123`).
### 4. Update Memo
Update an existing memo. Only detailed fields are updated.
```bash
ruby scripts/memos_cli.rb update --memo memos/123 --content "Updated content" --pinned true
```
**Options:**
- `--memo ID`: (Required) Target memo.
- `--content "STRING"`
- `--visibility VIS`
- `--pinned BOOL`
- `--state STATE`: Archive/Unarchive using `ARCHIVED` or `NORMAL`.
### 5. Delete Memo
Delete a memo permanently (or soft delete if the system supports it, but this CLI assumes standard delete).
```bash
ruby scripts/memos_cli.rb delete --memo memos/123
```
**Options:**
- `--memo ID`: (Required) Target memo.
- `--force true`: params to force delete if applicable.
## Output Format
**Success:**
```json
{
"ok": true,
"data": { ...memo object... }
}
```
**Error:**
```json
{
"ok": false,
"error": "Error message",
"http_status": 400,
"payload": { ... }
}
```Related Skills
mongodb-crud-operations
Master MongoDB CRUD operations, document insertion, querying, updating, and deletion. Learn BSON format, ObjectId, data types, and basic operations. Use when working with documents, collections, and fundamental MongoDB operations.
admin-crud
Generate admin dashboard pages with data tables, filters, bulk actions, dialogs, and forms. Use when building admin interfaces, management pages, or dashboard components.
api-platform-crud
Create complete REST API CRUD operations using API Platform 4 with DDD and CQRS patterns. Use when adding new API resources, implementing CRUD endpoints, creating DTOs, configuring operations, or setting up state processors. Follows the repository's hexagonal architecture with YAML resource configuration and command bus pattern.
bgo
Automates the complete Blender build-go workflow, from building and packaging your extension/add-on to removing old versions, installing, enabling, and launching Blender for quick testing and iteration.
nosql-expert
Expert guidance for distributed NoSQL databases (Cassandra, DynamoDB). Focuses on mental models, query-first modeling, single-table design, and avoiding hot partitions in high-scale systems.
nosql-databases
Apply NoSQL best practices for MongoDB, Convex, and document databases. Use when designing schemas, writing queries, optimizing performance, or building applications with non-relational databases. Use with database-expert for query optimization and DBA-level tuning (20+ years experience).
nodejs-javascript-vitest
Guidelines for writing Node.js and JavaScript code with Vitest testing Triggers on: **/*.js, **/*.mjs, **/*.cjs
nodejs-best-practices
Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.
nodejs-backend-typescript
Node.js backend development with TypeScript, Express/Fastify servers, routing, middleware, and database integration
nodejs-backend-patterns
Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices. Use when creating Node.js servers, REST APIs, GraphQL backends, or microservices architectures.
Node Tuning Helper Scripts
Generate tuned manifests and evaluate node tuning snapshots
nock-interpreter-engineer-assistant
Expert Nock interpreter builder for implementing virtual machines in C, Python, Rust, Haskell, or JavaScript. Use when building Nock interpreters, porting between languages, implementing evaluation loops, or understanding Nock runtime behavior.