🎯

pydantic-models

🎯Skill

from hainamchung/agent-assistant

What it does

Generates structured Pydantic models with Base, Create, Update, Response, and InDB variants for clean API and database model definitions in Python.

📦

Part of

hainamchung/agent-assistant(227 items)

pydantic-models

Installation

npm installInstall npm package

npm install -g @namch/agent-assistant

git cloneClone repository

git clone https://github.com/hainamchung/agent-assistant.git

Node.jsRun Node.js server

node cli/install.js install cursor # Cursor

Node.jsRun Node.js server

node cli/install.js install claude # Claude Code

Node.jsRun Node.js server

node cli/install.js install copilot # GitHub Copilot

+ 7 more commands

📖 Extracted from docs: hainamchung/agent-assistant

Need more details? View full documentation on GitHub →

1Installs

AddedFeb 4, 2026

View on GitHub Back to Skills

Skill Details

SKILL.md

Create Pydantic models following the multi-model pattern with Base, Create, Update, Response, and InDB variants. Use when defining API request/response schemas, database models, or data validation in Python applications using Pydantic v2.

Overview

# Pydantic Models

Create Pydantic models following the multi-model pattern for clean API contracts.

Quick Start

Copy the template from [assets/template.py](assets/template.py) and replace placeholders:

{{ResourceName}} → PascalCase name (e.g., Project)
{{resource_name}} → snake_case name (e.g., project)

Multi-Model Pattern

| Model | Purpose |

|-------|---------|

| Base | Common fields shared across models |

| Create | Request body for creation (required fields) |

| Update | Request body for updates (all optional) |

| Response | API response with all fields |

| InDB | Database document with doc_type |

camelCase Aliases

```python

class MyModel(BaseModel):

workspace_id: str = Field(..., alias="workspaceId")

created_at: datetime = Field(..., alias="createdAt")

class Config:

populate_by_name = True # Accept both snake_case and camelCase

```

Optional Update Fields

```python

class MyUpdate(BaseModel):

"""All fields optional for PATCH requests."""

name: Optional[str] = Field(None, min_length=1)

description: Optional[str] = None

```

Database Document

```python

class MyInDB(MyResponse):

"""Adds doc_type for Cosmos DB queries."""

doc_type: str = "my_resource"

```

Integration Steps

Create models in src/backend/app/models/
Export from src/backend/app/models/__init__.py
Add corresponding TypeScript types

More from this repository10

Skill

Develops high-performance C++ applications with modern C++20/23 features, template metaprogramming, and zero-overhead systems design.

🎯

senior-architect🎯Skill

Designs scalable software architectures using modern tech stacks, generating architecture diagrams, analyzing dependencies, and providing system design recommendations.

🎯

senior-frontend🎯Skill

Generates, analyzes, and scaffolds modern frontend projects using ReactJS, NextJS, TypeScript, and Tailwind CSS with automated best practices.

🎯

spec-miner🎯Skill

Extracts and documents specifications from legacy or undocumented codebases by systematically analyzing code structure, data flows, and system behaviors.

🎯

docs-seeker🎯Skill

Searches and retrieves technical documentation by executing intelligent scripts across library sources, GitHub repos, and context7.com with automated query detection.

🎯

writing-plans🎯Skill

Generates comprehensive, step-by-step implementation plans for software features with precise file paths, test-driven development approach, and clear task granularity.

🎯

file path traversal testing🎯Skill

Tests and identifies potential file path traversal vulnerabilities in code by analyzing file path handling and input validation mechanisms.

🎯

nodejs-best-practices🎯Skill

Guides developers in making strategic Node.js architecture and framework decisions by providing context-aware selection principles and modern runtime considerations.

🎯

red-team-tactics🎯Skill

Simulates adversarial attack techniques across MITRE ATT&CK framework phases, mapping network vulnerabilities and demonstrating systematic compromise strategies.