Developer Skills Workspace

Welcome to the Skills workspace. This repository is a curated collection of structured blueprints, architect manuals, and reference patterns for 8 developer skills. It functions as both a personal reference center and a capability store for agentic development.

To make this page highly readable and interactive, we've organized the domain references inside collapsible blocks below. You can copy the code from this file directly into your Git repository's README.md.

⚡ Quick CLI Installation & Setup

You can install and deploy these skills directly to your coding environments (such as Claude Code, Gemini CLI, Copilot, Cursor, etc.) with zero dependencies using the matching npx command:

# Register skills inside Cursor (.cursorrules) or mount as Claude Desktop MCP filesystem server
npx developer-skills-bank

What the installer handles:

• Cursor IDE: Automates copying specific skill files directly into a project's .cursorrules file or combines all skills into a single set of rules.
• Claude Desktop: Updates your local claude_desktop_config.json to auto-mount this entire skills directory as a filesystem MCP server, exposing all manuals as reference material for the LLM.
• Claude Code / Gemini CLI / Copilot: Instructs you on how to point these CLI runners to the skills folders or feed skill specs directly into current terminal sessions.

🛠️ Technology Stack & Badges

Below are the main frameworks, languages, and tools documented across these developer skills:

📂 Directory Overview

skills/
├── LangChain/            # LangChain v1 / LangGraph / Deep Agents (2026 Shift)
├── Llamaindex/           # Data Ingestion, Vector DBs, & Q&A RAG Pipelines
├── MongoDB/              # NoSQL Document Modeling, Aggregations, & Atlas Setup
├── PostgreSQL/           # SQL Fundamentals, Advanced Queries, & Operations
├── React/                # React + FastAPI AI UI/UX (Streaming, Agentic Panels)
├── docker-k8s-mlops/     # Containerization, Kubernetes Orchestration, & MLOps
├── fastapi_skill/        # High-performance FastAPI Backend Design & Auth
└── mcp/                  # Model Context Protocol (FastMCP Servers & Transports)

💡 Core Skills Summary

Here is a summary of each skill and direct links to their entrypoint manuals:

| Skill | Description | Entrypoint | | :------------------ | :----------------------------------------------------------------------- | :----------------------------------------------------- | | LangChain | Modern LLM applications using LangChain v1, LangGraph, and Deep Agents. | LangChain/SKILL.md | | LlamaIndex | Lead connector framework for context-augmented Q&A/RAG pipelines. | Llamaindex/SKILL.md | | MongoDB | NoSQL document modeling, compound indexes (ESR), and aggregations. | MongoDB/SKILL.md | | PostgreSQL | Relational schemas, analytical window queries, CTEs, and JSONB data. | PostgreSQL/SKILL.md | | React + FastAPI | AI UIs, Event Sources (SSE), websocket streaming, and proxy gateways. | React/SKILL.md | | Docker + K8s | Multi-stage image builds, liveness/readiness probes, and GPU scheduling. | docker-k8s-mlops/SKILL.md | | FastAPI | Clean API design, Pydantic validation, dependency injection, and auth. | fastapi_skill/SKILL.md | | MCP | Model Context Protocol spec (server tools, resources, and prompts). | mcp/SKILL.md |

🔍 Detailed Skill Roundups & References

Click on any panel below to expand and view the reference blueprints and guidelines.

• Focus: Replaces legacy AgentExecutor chains with middleware-extensible graph models using LangGraph and Deep Agents.
• Key Reference Docs:
  • models.md — Model initializations, streaming, and tool calling basics.
  • agents.md — Detailed configurations for single and multi-agent harnesses.
  • memory.md — State management, checkpointers, and persistent session storage.
  • middleware.md — Writing hooks to intercept tool execution and model requests.
  • learning_path.md — Structured curriculum from beginner concepts to Production Graphs.

• Focus: Data indexing and query retrievers. Optimizes loading documents via parsers and building advanced indexing strategies.
• Key Reference Docs:
  • rag_fundamentals.md — Fundamental steps of retrieval-augmented generation.
  • loading_and_nodes.md — Schema parsing, Ingestion pipelines, and custom node splitters.
  • indexing_and_embeddings.md — Vector, Summary, and advanced PropertyGraph indices.
  • vector_databases.md — Integration configurations for databases like ChromaDB, Pinecone, and pgvector.
  • workflows.md — Event-driven loops, step functions, and concurrency control.

• Focus: Optimized JSON document storage. Prioritizes queries when designing database schemas.
• Key Reference Docs:
  • data_modeling.md — Decisions criteria on when to embed nested data vs. join collections.
  • indexes.md — Setup guidelines for compound indexes (ESR rules).
  • aggregation.md — Pipeline architecture, stages usage, and indexing integrations.
  • mongoose.md — Schema layers, validations, and custom model middleware in Express apps.

• Focus: Traditional relational mapping and SQL queries. Combines tabular schemas with hybrid unstructured columns.
• Key Reference Docs:
  • datatypes_and_design.md — Structured schemas, identities, and JSONB documents.
  • queries.md — Advanced analytics (window functions, subqueries, and CTE expressions).
  • indexs_and_performance.md — B-trees, GIN indexes, and using EXPLAIN ANALYZE logs.
  • transactions_and_concurrency.md — Row locking configurations and MVCC transactional states.

• Focus: Structuring client-facing AI layouts. Develops clean event structures to display agent reasoning states.
• Key Reference Docs:
  • streaming_and_llm_ui.md — Client fetching protocols using SSE and WebSockets.
  • chat_ui_patterns.md — Rich text styling, scroll managers, and cancel hooks.
  • agentic_ui_patterns.md — Interactive step logs, trace visualizations, and human-in-the-loop approvals.
  • fastapi_ml_services.md — Serving scikit-learn or PyTorch weight loads with FastAPI lifespans.

• Focus: Pipeline deployment. Coordinates scalable container layers for backend services and ML inference.
• Key Reference Docs:
  • dockerfiles_for_ml.md — Multi-stage builds, dependencies caching, and image size constraints.
  • probs_and_healing.md — Defining liveness/readiness thresholds to avoid weight loading timeouts.
  • gpu_on_kubernetes.md — Device configurations, quotas scheduler, and node pools matching.
  • cicd_and_gitops.md — Automatic rollback pipelines using GitOps operators.

• Focus: Reusable backend layout with clean validation. Built around Pydantic schema validation.
• Key Reference Docs:
  • DATABASE.md — SQLAlchemy connection pipelines, Session handlers, and Alembic migrations.
  • Auth.md — OAuth2 authentication setups, JWT generation, and password hashing guards.
  • TEST.md — Writing pytest fixtures with db overrides and async network mocks.
  • DEPLOYMENT.md — Gunicorn/Uvicorn configurations, Docker wrapping, and production logs setup.

• Focus: Flexible client-server communication. Exposes local resources and actions cleanly to any AI host.
• Key Reference Docs:
  • tools_resource_prompts.md — Customizing entry parameters and return schemas.
  • building_servers.md — Setup protocols using FastMCP wrapper decorators.
  • transports.md — Standard input/output streams vs. remote HTTP and ASGI mount pathways.
  • security.md — Mitigating sandbox escalations, prompt injections, and token poisoning.

🧭 How to Consult & Use the Skills

To query a specific skill or build a project using these guides, follow the standard workflow:

graph TD
    User([User Request / Task]) --> Route{Identify Domain}
    Route -->|LangChain agent| LC[Read LangChain/SKILL.md]
    Route -->|RAG pipeline| LI[Read Llamaindex/SKILL.md]
    Route -->|DB Schema / Query| DB[Read MongoDB/SKILL.md or PostgreSQL/SKILL.md]
    Route -->|Frontend / Gateway| FE[Read React/SKILL.md]
    Route -->|Deployment / Infra| OPS[Read docker-k8s-mlops/SKILL.md]
    Route -->|API Business Logic| API[Read fastapi_skill/SKILL.md]
    Route -->|AI Tooling spec| MCP[Read mcp/SKILL.md]

    LC --> Consult[Consult references/ directory for targeted blueprints & guidelines]
    LI --> Consult
    DB --> Consult
    FE --> Consult
    OPS --> Consult
    API --> Consult
    MCP --> Consult

1. Check the Entrypoint: Start by reading the root SKILL.md of the relevant folder. It holds best practices, quick install setup commands, and a code stub.
2. Follow the Routing Map: Look at the table inside SKILL.md to find the exact reference file. For example, if you need help with Pydantic Validation in FastAPI, the route redirects you to referencs/DATABASE.md.
3. Execute and Verify: Test your implementations against the best practices summarized in each entrypoint, utilizing the learning paths to resolve any troubleshooting issues.