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.
Si lo creaste tú, pega este código en tu README. La insignia enlaza a esta página.
[](https://mcp.popnx.com/en/skills/benavlabs-fastcrud)Servidores MCP que conectan la IA a servicios para el mismo trabajo
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
Mismo tipo de trabajo, ordenadas como la lista de Skills
| Este fastcrud | rea | andrej-karpathy-skills | graphify | MoneyPrinterTurbo | |
|---|---|---|---|---|---|
| Autor | benavlabs | morluto | multica-ai | Graphify-Labs | harry0703 |
| Skills | 1 | 1 | 1 | 1 | 1 |
| Estrellas de GitHub | 1602 | 465.460 | 233.910 | 149.364 | 144.149 |
| Último cambio de código | 12 oct 2026 | 17 nov 2026 | 20 abr 2026 | 17 nov 2026 | 17 nov 2026 |
| Licencia | MIT | MIT | – | Apache-2.0 | MIT |
1 skills (conjuntos de instrucciones) de benavlabs que la IA lee y sigue · no es un MCP server
MCP = las manos
Conecta la IA a un servicio o dato externo, como leer Notion o crear una factura. Necesita un programa o servidor en marcha.
Skill = el manual
Un archivo de texto que enseña a la IA cómo hacer una tarea. No se conecta a nada.
A veces se parecen: algunas Skills ejecutan scripts que llaman herramientas y algunos MCP solo envían conocimiento. Empieza por la tarea que quieres hacer.
Claude CodeCodexCursorGitHub CopilotOpenCode
Según el README del autor y las carpetas del repo
GitHub account benavlabs (organization), 1 years old
★ 1602 stars · code last changed 12 oct 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
Primero: ¿qué IA usas?
Elige tu app y esta página mostrará solo cómo instalarlo en ella
Uploading to claude.ai would fail: the description is over 200 characters (622). Use "Let the AI install it" instead
Copia esta frase y pégala en un chat de Claude Code
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
Vuelve a abrir Claude Code y escribe /fastcrud, o pide una tarea relacionada y Claude lo usará
Checked against official docs 12 nov 2026 · Source: code.claude.com
Un Skill son instrucciones que la IA seguirá. Lee los archivos antes de instalar e instala solo de autores de confianza.
Mac: pulsa Command+Espacio y escribe Terminal · Windows: el comando no funciona en PowerShell; usa «Que la IA lo instale» arriba
Descarga el repo a una carpeta temporal y copia solo las carpetas con 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/fastcrudLa app de escritorio de ChatGPT incluye Codex, y Codex lee las skills de la carpeta ~/.agents/skills
Abre Codex en la app de escritorio de ChatGPT y pega esta frase en el chat
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
Coloca la carpeta fastcrud en ~/.agents/skills/fastcrud
~ es tu carpeta de inicio ($HOME)
Un Skill son instrucciones que la IA seguirá. Lee los archivos antes de instalar e instala solo de autores de confianza.
Mac: pulsa Command+Espacio y escribe Terminal · Windows: el comando no funciona en PowerShell; usa «Que la IA lo instale» arriba
Descarga el repo a una carpeta temporal y copia solo las carpetas con 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
Las skills que instalas tú no funcionan aquí; solo las que vienen con un plugin del directorio
Para usar esta skill con ChatGPT, usa la app de escritorio de ChatGPT como se indica arriba
Checked against official docs 15 nov 2026 · Source: learn.chatgpt.com
Copia esta frase y pégala en un chat de Codex · Sirve en Codex dentro de la app de escritorio de ChatGPT, en Codex CLI y en la extensión del IDE
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 detecta solo las skills recién instaladas; si una no aparece, reinicia Codex · Para usarla: en ChatGPT escribe @ y elige la skill · en Codex CLI o la extensión del IDE ejecuta /skills o escribe $ y el nombre de la skill
Checked against official docs 15 nov 2026 · Source: learn.chatgpt.com
Un Skill son instrucciones que la IA seguirá. Lee los archivos antes de instalar e instala solo de autores de confianza.
Mac: pulsa Command+Espacio y escribe Terminal · Windows: el comando no funciona en PowerShell; usa «Que la IA lo instale» arriba
Descarga el repo a una carpeta temporal y copia solo las carpetas con 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/fastcrudCopia esta frase y pégala en un chat de Cursor
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
En el chat Agent de Cursor escribe / y elige fastcrud
Checked against official docs 12 nov 2026 · Source: cursor.com
Un Skill son instrucciones que la IA seguirá. Lee los archivos antes de instalar e instala solo de autores de confianza.
Mac: pulsa Command+Espacio y escribe Terminal · Windows: el comando no funciona en PowerShell; usa «Que la IA lo instale» arriba
Descarga el repo a una carpeta temporal y copia solo las carpetas con 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/fastcrudPara otras apps que leen skills. La frase incluye las rutas de Claude Code, Codex y Cursor para que la IA elija la de tu app · 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
Otras apps con Agent Skills (como Gemini CLI o GitHub Copilot) usan otras carpetas. Mira la guía de esa app y copia allí la carpeta con el SKILL.md.
Carpetas de skills comprobadas con las guías oficiales de Claude Code, Codex y Cursor el 11 nov 2026
✓ Comandos revisados el 18 nov 2026
El texto siguiente viene del repo del autor, no de PopNx MCP
Se muestran los primeros 8000 caracteres · Abrir el archivo completo en GitHub
---
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=NoPregunta, comparte un consejo o avisa de que no funciona. Ordenado por lo que la gente marcó como útil.
Aún no hay publicaciones. Sé la primera persona en preguntar o compartir.
Lo publicado aquí lo escriben usuarios, no el equipo de PopNx.