REA
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
FastCRUD is a Python package for FastAPI, offering robust async CRUD operations and flexible endpoint creation utilities.
Wenn du das gebaut hast, füge diesen Code in dein README ein. Das Badge verlinkt auf diese Seite.
[](https://mcp.popnx.com/en/skills/benavlabs-fastcrud)MCP-Server, die die KI für dieselbe Arbeit mit Diensten verbinden
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Codebase intelligence for TypeScript and JavaScript, exposed as structured MCP analysis tools.
MCP server for terminal commands, file operations, and process management
Gleiche Art Arbeit, sortiert wie die Skill-Liste
| Dieser fastcrud | rea | andrej-karpathy-skills | graphify | MoneyPrinterTurbo | |
|---|---|---|---|---|---|
| Anbieter | benavlabs | morluto | multica-ai | Graphify-Labs | harry0703 |
| Skills | 1 | 1 | 1 | 1 | 1 |
| GitHub-Sterne | 1.602 | 465.460 | 233.910 | 149.364 | 144.149 |
| Letzte Codeänderung | 12. Okt. 2026 | 17. Nov. 2026 | 20. Apr. 2026 | 17. Nov. 2026 | 17. Nov. 2026 |
| Lizenz | MIT | MIT | – | Apache-2.0 | MIT |
1 Skills (Anweisungssammlungen) von benavlabs, die eine KI liest und befolgt · kein MCP-Server
MCP = die Hände
Verbindet die KI mit einem externen Dienst oder Daten, etwa Notion lesen oder eine Rechnung erstellen. Ein Programm oder Server muss laufen.
Skill = das Handbuch
Eine Textdatei, die der KI zeigt, wie eine Aufgabe geht. Sie verbindet sich mit nichts.
Manches überschneidet sich: Einige Skills starten Skripte mit Werkzeugen, einige MCP-Server liefern nur Wissen. Geh von der Aufgabe aus.
Claude CodeCodexCursorGitHub CopilotOpenCode
Laut README des Anbieters und den Ordnern im Repo
GitHub account benavlabs (organization), 1 years old
★ 1.602 stars · code last changed 12. Okt. 2026
No, plain text files the AI reads and follows
No scripts, so it does not go online by itself
No hooks or writes to machine settings found
Checked automatically from the repo files at commit 27f2cba (read only, nothing was run). Not a safety guarantee: read it and decide for yourself
Zuerst: Welche KI nutzt du?
Wähle deine App, dann zeigt diese Seite nur die Installation für diese App
Uploading to claude.ai would fail: the description is over 200 characters (622). Use "Let the AI install it" instead
Kopiere diesen Satz und füge ihn in einen Claude Code-Chat ein
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Claude Code neu starten, dann /fastcrud tippen oder eine passende Aufgabe stellen; Claude nutzt den Skill
Checked against official docs 12. Nov. 2026 · Source: code.claude.com
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/benavlabs/fastcrud.git /tmp/popnx-skill-benavlabs-fastcrud-27f2cba && mkdir -p ~/.claude/skills && cp -R '/tmp/popnx-skill-benavlabs-fastcrud-27f2cba/fastcrud/.agents/skills/fastcrud' ~/.claude/skills/fastcrudSelbst installierte Skills funktionieren in der ChatGPT-Desktop-App, in Codex CLI und in der Codex-Erweiterung für die IDE · ChatGPT im Web und auf dem Handy kann selbst installierte Skills nicht nutzen, nur Skills, die mit einem Plugin aus dem Verzeichnis kommen
Die ChatGPT-Desktop-App enthält Codex, und Codex liest Skills aus dem Ordner ~/.agents/skills
Öffne Codex in der ChatGPT-Desktop-App und füge diesen Satz in den Chat ein
The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Lege den Ordner fastcrud unter ~/.agents/skills/fastcrud ab
~ ist dein Home-Ordner ($HOME)
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/benavlabs/fastcrud.git /tmp/popnx-skill-benavlabs-fastcrud-27f2cba && mkdir -p ~/.agents/skills && cp -R '/tmp/popnx-skill-benavlabs-fastcrud-27f2cba/fastcrud/.agents/skills/fastcrud' ~/.agents/skills/fastcrudChecked against official docs 15. Nov. 2026 · Source: learn.chatgpt.com
Selbst installierte Skills funktionieren hier nicht, nur Skills, die mit einem Plugin aus dem Verzeichnis kommen
Um diesen Skill mit ChatGPT zu nutzen, verwende die ChatGPT-Desktop-App wie oben beschrieben
Checked against official docs 15. Nov. 2026 · Source: learn.chatgpt.com
Kopiere diesen Satz und füge ihn in einen Codex-Chat ein · Funktioniert in Codex in der ChatGPT-Desktop-App, in Codex CLI und in der IDE-Erweiterung
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Codex erkennt neu installierte Skills selbst; wenn einer nicht erscheint, starte Codex neu · So nutzt du ihn: In ChatGPT @ tippen und den Skill wählen · in Codex CLI oder der IDE-Erweiterung /skills ausführen oder $ und den Skill-Namen tippen
Checked against official docs 15. Nov. 2026 · Source: learn.chatgpt.com
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/benavlabs/fastcrud.git /tmp/popnx-skill-benavlabs-fastcrud-27f2cba && mkdir -p ~/.agents/skills && cp -R '/tmp/popnx-skill-benavlabs-fastcrud-27f2cba/fastcrud/.agents/skills/fastcrud' ~/.agents/skills/fastcrudKopiere diesen Satz und füge ihn in einen Cursor-Chat ein
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Im Agent-Chat von Cursor / tippen und fastcrud wählen
Checked against official docs 12. Nov. 2026 · Source: cursor.com
Ein Skill sind Anweisungen, denen die KI folgt. Lies die Dateien vor der Installation und installiere nur von vertrauenswürdigen Anbietern.
Mac: Command+Leertaste und Terminal tippen · Windows: Der Befehl unten funktioniert nicht in PowerShell; nutze oben „KI installiert es“
Lädt das Repo in einen temporären Ordner und kopiert nur Ordner mit einer SKILL.md
git clone --depth 1 https://github.com/benavlabs/fastcrud.git /tmp/popnx-skill-benavlabs-fastcrud-27f2cba && mkdir -p ~/.cursor/skills && cp -R '/tmp/popnx-skill-benavlabs-fastcrud-27f2cba/fastcrud/.agents/skills/fastcrud' ~/.cursor/skills/fastcrudFür andere Apps, die Skills lesen. Der Satz enthält die Pfade für Claude Code, Codex und Cursor, damit die KI den für deine App wählt · Copy this sentence into the app’s chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Checked against official docs 12. Nov. 2026 · Source: code.claude.com, learn.chatgpt.com, cursor.com
Andere Apps mit Agent Skills (etwa Gemini CLI oder GitHub Copilot) nutzen andere Ordner. Sieh in deren Anleitung nach und kopiere den Ordner mit der SKILL.md dorthin.
Skill-Ordner am 11. Nov. 2026 mit den offiziellen Anleitungen von Claude Code, Codex und Cursor geprüft
✓ Befehle geprüft am 18. Nov. 2026
Der folgende Text stammt aus dem Repo des Anbieters, nicht von PopNx MCP
Die ersten 8.000 Zeichen · Ganze Datei auf GitHub öffnen
---
name: fastcrud
description: Use when building or modifying CRUD endpoints with FastCRUD (the `fastcrud` PyPI package) in a FastAPI project — covers `FastCRUD`, `crud_router`, `EndpointCreator`, `FilterConfig`, `JoinConfig`, auto-relationship detection, the filter operator syntax (`__gte`, `__in`, `__ilike`, etc.), cursor pagination, soft delete, and how to avoid N+1 queries when fetching related data. Activate when the user mentions FastCRUD, `crud_router`, `FastCRUD()`, `FilterConfig`, `JoinConfig`, or asks how to build CRUD endpoints / generate REST APIs from SQLAlchemy or SQLModel models, even if the user doesn't name the library directly.
license: MIT
metadata:
author: benav-labs
package: fastcrud
---
# FastCRUD
FastCRUD generates async CRUD methods (and optionally CRUD endpoints) for SQLAlchemy 2.0 models inside a FastAPI app. The two entry points are:
- **`FastCRUD(Model)`** — the data-access class. Use this for per-row CRUD operations (single-record get / create / update / delete, paginated lists, joins with relationships). Real codebases use this in services, workers, and custom endpoints.
- **`crud_router(...)`** — returns an `APIRouter` with create/read/update/delete endpoints auto-wired. Use this only when you want generated endpoints; many apps skip it and hand-roll FastAPI routes on top of `FastCRUD` instances.
This skill covers the public API across `fastcrud >= 0.22`; features marked (v0.23+) need `fastcrud >= 0.23`. SQLAlchemy is the default ORM in examples; SQLModel works the same way except where noted.
**Before reaching for FastCRUD, check the [When NOT to use FastCRUD](#when-not-to-use-fastcrud) section below.** Aggregate roll-ups, CTEs, `GROUP BY` projections, and bulk writes are SQLAlchemy's job — FastCRUD is for per-row CRUD.
---
## Canonical setup
The minimal viable pattern. Always start here, then add filters/joins/relationships as needed.
```python
# models.py
from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import DeclarativeBase, relationship
class Base(DeclarativeBase): pass
class Tier(Base):
__tablename__ = "tier"
id = Column(Integer, primary_key=True)
name = Column(String, unique=True)
class User(Base):
__tablename__ = "user"
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String, unique=True)
tier_id = Column(Integer, ForeignKey("tier.id"))
tier = relationship("Tier")
```
```python
# schemas.py
from pydantic import BaseModel, ConfigDict
class UserCreate(BaseModel):
name: str
email: str
tier_id: int
class UserRead(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: int
name: str
email: str
tier_id: int
class UserUpdate(BaseModel):
name: str | None = None
email: str | None = None
```
```python
# main.py
from fastapi import FastAPI
from fastcrud import crud_router
from .db import get_async_session
from .models import User
from .schemas import UserCreate, UserRead, UserUpdate
app = FastAPI()
user_router = crud_router(
session=get_async_session, # callable returning AsyncSession (FastAPI dependency)
model=User,
create_schema=UserCreate,
update_schema=UserUpdate,
select_schema=UserRead, # used for read responses
path="/users",
tags=["users"],
)
app.include_router(user_router)
```
This produces `POST /users`, `GET /users/{id}`, `PATCH /users/{id}`, `DELETE /users/{id}`, `DELETE /users/db_delete/{id}` (hard delete), and `GET /users` (paginated list).
---
## Choosing the right method
When using `FastCRUD(Model)` directly, pick the method that matches the data shape you actually need. **Do not loop over `get_multi()` and call `get_joined()` per row** — that's the canonical N+1.
| Need | Use |
|---------------------------------------------|------------------------------|
| Single row, no joins | `get(db, id=...)` |
| Single row with related data | `get_joined(db, id=...)` |
| Paginated list, no joins | `get_multi(db, offset, limit)` |
| **Paginated list with related data** | **`get_multi_joined(db, ...)`** |
| Cursor-paginated list (infinite scroll) | `get_multi_by_cursor(db, ...)` |
| Insert | `create(db, schema)` |
| Insert-or-update by unique constraint | `upsert(db, schema)` / `upsert_multi(db, list)` |
| Patch by filters | `update(db, schema, **kwargs)` |
| Soft delete (if configured) | `delete(db, **kwargs)` |
| Hard delete (always removes row) | `db_delete(db, **kwargs)` |
| Count | `count(db, **kwargs)` |
| Boolean existence check | `exists(db, **kwargs)` |
---
## Avoiding N+1 — the most common mistake
FastCRUD has two mechanisms to prevent N+1 when fetching related data. **Use one of them — never iterate.**
### 1. Auto-detect relationships (zero config, default for v0.21+)
Set `include_relationships=True` on `crud_router` (or `auto_detect_relationships=True` on the FastCRUD method directly). FastCRUD inspects the SQLAlchemy mapper, builds the joins, and threads them through a single query.
```python
crud_router(
session=get_async_session,
model=User,
create_schema=UserCreate,
update_schema=UserUpdate,
select_schema=UserWithTier, # schema includes nested tier field
include_relationships=True, # auto-include all relationships
path="/users",
)
```
Or pass a list to include only specific relationships:
```python
include_relationships=["tier", "department"] # whitelist
```
**Gotcha:** **One-to-many relationships are excluded by default** because they can return unbounded data. Opt in explicitly:
```python
include_relationships=True,
include_one_to_many=True,
default_nested_limit=10, # cap nested rows per parent (uses SQL window function)
```
`default_nested_limit` uses `row_number() OVER (PARTITION BY ...)` at the database level — it does **not** fetch everything and slice in Python.
### 2. Manual `JoinConfig` (when you need explicit control)
For self-joins, aliases, custom join conditions, or per-join schemas:
```python
from fastcrud import FastCRUD, JoinConfig
orders_with_user = await crud.get_multi_joined(
db=session,
joins_config=[
JoinConfig(
model=User,
join_on=Order.user_id == User.id,
join_prefix="user_", # avoid column collisions
schema_to_select=UserRead,
),
],
offset=0,
limit=20,
)
```
For one-to-many with per-parent capping:
```python
JoinConfig(
model=Article,
join_on=Article.author_id == Author.id,
relationship_type="one-to-many",
sort_columns="created_at",
sort_orders="desc",
nested_limit=5, # 5 most recent articles per author, computed in SQL
)
```
See `references/joins.md` for the full `JoinConfig` spec, polymorphic inheritance, and the auto-detection rules.
---
## `limit=None` — the second biggest footgun
`get_multi(...)` / `get_multi_joined(...)` accept `limit=None` to fetch **every matching row**. This is the single biggest cause of latency cliffs and OOMs in real-world FastCRUD code.
**Rule:** `limit=None` is only safe when a `WHERE` clause domain-bounds the result to a known-small set. Otherwise, always pass an explicit numeric `limit`.
### Safe — scoped by a WHERE clause
```python
# OK: scoped to a single project → bounded by N(clips per project)
clips = await crud_clips.get_multi(db, limit=None, project_id=project.id)
# OK: scoped to a small known set of IDs
tiers = await crud_tiers.get_multi(db, limit=None, id__in=tier_ids)
```
### Unsafe — unbounded growth
```python
# BAD: grows linearly with the user table forever
users = await crud_users.get_multi(db, limit=NoFragen, Tipps teilen oder melden, dass etwas nicht geht. Sortiert nach „hilfreich“.
Noch keine Beiträge. Stell die erste Frage oder teile einen Tipp.
Beiträge hier stammen von Nutzern, nicht vom PopNx-Team.