DEV Community: Kacper Włodarczyk

Pydantic Deep Agents 0.3.3: ACP, Thinking, Lifecycle Hooks, and Opinionated Defaults

Kacper Włodarczyk — Thu, 02 Apr 2026 15:29:56 +0000

We just released pydantic-deep 0.3.3 — and this is the biggest release since we open-sourced the project. ACP support, deep subagents by default, thinking, Anthropic caching, lifecycle hooks, skills as slash commands, and a provider setup wizard.

Let's walk through the changes.

ACP: Your Agent in Any Editor

ACP (Agent Client Protocol) is a standardized protocol that lets AI agents run inside editors. Think of it like LSP, but for AI agents instead of language servers.

Our new apps/acp/ adapter exposes any pydantic-deep agent as an ACP-compatible server. The same agent you run in your terminal now runs in Zed with zero code changes.

What you get:

Streaming text deltas — real-time output, not waiting for completion
Tool call visibility — see tool names, arguments, and results (not a black box)
Model switching — change from Claude to GPT mid-session
Session management — conversation persistence across editor restarts
Auto-detect provider — reads your API keys, no manual config

The adapter wraps the same create_deep_agent() you already use. No new API to learn.

Because ACP is a protocol (not a Zed-specific plugin), it'll work with any editor that adopts it. We expect more editors to support ACP in the coming months.

Subagents Are Now Deep Agents by Default

This is the change that affects the most users.

Previously, subagents were plain pydantic-ai Agents — lightweight, but limited. They couldn't read files, search the web, or remember things between runs.

Now, every subagent (built-in and custom) is created via create_deep_agent() with:

Filesystem access (read, write, edit, grep, glob)
Web search and web fetch
Persistent memory
Large output eviction (auto-save to files when output exceeds 20K tokens)
Orphaned tool call patching

If your custom subagent doesn't specify agent or agent_factory, it automatically gets the full deep agent factory. You don't have to change anything — your subagents just got more capable.

We also replaced include_general_purpose_subagent with include_builtin_subagents, which adds a "research" deep agent for codebase exploration and web research.

Thinking Enabled by Default

thinking="high" is now the default. This enables model reasoning via pydantic-ai's Thinking capability.

We support 7 levels:

agent = create_deep_agent(
    model="anthropic:claude-opus-4-6",
    thinking="high",  # default
    # Options: True, False, "minimal", "low", "medium", "high", "xhigh"
)

For models that don't support thinking (like GPT-4.1), the parameter is silently ignored.

Anthropic Prompt Caching — On by Default

Three new defaults enabled automatically:

anthropic_cache_instructions — cache system prompt
anthropic_cache_tool_definitions — cache tool schemas
anthropic_cache_messages — cache conversation history

This reduces token costs and latency for Anthropic models significantly. For non-Anthropic models, these settings are silently ignored.

5 New Lifecycle Hooks

class HookEvent(Enum):
    BEFORE_RUN = "before_run"
    AFTER_RUN = "after_run"
    RUN_ERROR = "run_error"
    BEFORE_MODEL_REQUEST = "before_model_request"
    AFTER_MODEL_REQUEST = "after_model_request"

These map directly to pydantic-ai's lifecycle hooks. Use cases:

Session tracking — log when an agent run starts and ends
LLM call logging — capture every model request for debugging
Error alerts — get notified when a run fails
Cost monitoring — track token usage per request

Skills as Slash Commands

Skills now work as slash commands in the CLI. Type /code-review and the skill activates directly from the picker.

Discovery follows a 3-tier hierarchy:

Built-in (apps/cli/skills/) — ships with pydantic-deep
User (~/.pydantic-deep/skills/) — your personal skills
Project (.pydantic-deep/skills/) — project-specific skills

Later sources override earlier ones by name, so you can customize built-in skills per project.

Other Notable Changes

compact_conversation tool — the agent can manually trigger context compression with an optional focus topic
Provider setup wizard — first-run auto-detects missing API keys and guides through provider selection
/provider slash command — switch AI provider and model mid-session
/config slash command — view and change settings interactively
approve_tools config — choose which tools need user approval (default: ["execute"])
Enhanced BASE_PROMPT — Claude Code-inspired sections for code quality, careful execution, and formatting
Context files simplified to AGENTS.md and SOUL.md only

Opinionated Defaults

The philosophy behind 0.3.3: make the powerful thing the default thing.

Setting	Before	After
Memory	off	on
Thinking	off	`"high"`
Prompt caching	off	on (Anthropic)
Subagent type	plain Agent	deep agent
Max nesting depth	0	1
Eviction limit	none	20K tokens
Patch tool calls	off	on

You get a capable, production-ready agent with create_deep_agent("anthropic:claude-opus-4-6"). No configuration needed.

Get Started

pip install pydantic-deep-agents

Or try the CLI:

pip install pydantic-deep-agents[cli]
pydantic-deep

Full changelog: CHANGELOG.md

Repo: github.com/vstorm-co/pydantic-deepagents

We build open-source AI agent tooling at Vstorm. pydantic-deep is our framework — modular, type-safe, production-tested across 30+ deployments.

Pydantic AI Capabilities, Hooks & Agent Specs - What Changed and How Our Libraries Migrated

Kacper Włodarczyk — Mon, 30 Mar 2026 14:38:10 +0000

Pydantic AI just shipped the biggest API change since launch. Capabilities, hooks, and agent specs landed in v1.71+, and they fundamentally change how you extend agents.

We maintain 5 open-source libraries built on top of Pydantic AI: pydantic-ai-shields (formerly pydantic-ai-middleware), pydantic-ai-subagents, pydantic-ai-summarization, pydantic-ai-backend, and the full-stack AI agent template. All five have been migrated. This article covers what changed, why it matters, and real before/after code from our repos.

What Are Capabilities?

Capabilities are reusable, composable units of agent behavior. Instead of threading multiple configuration arguments separately -- tools here, instructions there, model settings somewhere else -- a capability bundles everything into a single capabilities parameter on the Agent constructor.

Each capability can provide:

Tools (via get_toolset())
Instructions (static strings or dynamic callables)
Model settings (per-step configuration)
Lifecycle hooks (before/after/wrap patterns for runs, model requests, tool calls)
Tool preparation (filter or modify tool definitions per step)

The base class is AbstractCapability. You subclass it, override the methods you need, and pass instances to the agent:

from pydantic_ai import Agent
from pydantic_ai.capabilities import AbstractCapability

agent = Agent(
    "openai:gpt-4.1",
    capabilities=[MyCapability(), AnotherCapability()],
)

Multiple capabilities compose automatically. Before-hooks fire in order (cap1 then cap2), after-hooks fire reversed (cap2 then cap1), and wrap-hooks nest as middleware layers. This is not something we had to build -- the framework handles it.

What Are Hooks?

Hooks are the lifecycle interception points within capabilities. Pydantic AI provides hooks at four levels:

Run hooks -- before_run, wrap_run, after_run, on_run_error
Node hooks -- before_node_run, wrap_node_run, after_node_run, on_node_run_error
Model request hooks -- before_model_request, wrap_model_request, after_model_request, on_model_request_error
Tool hooks -- split into validation and execution phases, each with before/wrap/after/error variants

Plus prepare_tools for filtering tool visibility per step.

That's roughly 20 hook points across 4 lifecycle levels. Error hooks use a neat pattern: raise to propagate, return to recover. If your error handler raises the original exception, it propagates unchanged. Raise a different exception to transform the error. Return a result to suppress it entirely.

For simple use cases, the Hooks capability gives you decorator-based registration without subclassing:

from pydantic_ai.capabilities import Hooks

hooks = Hooks()

@hooks.on.before_model_request
async def log_request(ctx, request_context):
    print(f"Sending {len(request_context.messages)} messages")
    return request_context

agent = Agent("openai:gpt-4.1", capabilities=[hooks])

What Are Agent Specs?

Agent specs separate agent configuration from code entirely. You define your agent in YAML or JSON:

model: anthropic:claude-opus-4-6
instructions: You are a helpful assistant.
capabilities:
  - WebSearch
  - Thinking:
      effort: high

Then load it:

agent = Agent.from_file("agent.yaml")

Capabilities that implement get_serialization_name() and from_spec() are automatically available. This means your custom capabilities can be YAML-driven too.

How Our Libraries Migrated

pydantic-ai-middleware to pydantic-ai-shields

This was the most dramatic change. Our middleware library had grown to include MiddlewareAgent, MiddlewareChain, ParallelMiddleware, ConditionalMiddleware, PipelineSpec, config loaders, a compiler -- a whole parallel abstraction layer.

We deleted all of it.

The v0.3.0 release renamed the package to pydantic-ai-shields and rebuilt everything as capabilities.

Before (middleware era):

from pydantic_ai_middleware import MiddlewareAgent, CostTrackingMiddleware

middleware_agent = MiddlewareAgent(
    agent,
    middlewares=[CostTrackingMiddleware(budget_limit_usd=5.0)]
)
result = await middleware_agent.run("Hello")

After (capabilities era):

from pydantic_ai import Agent
from pydantic_ai_shields import CostTracking, PromptInjection, PiiDetector

agent = Agent(
    "openai:gpt-4.1",
    capabilities=[
        CostTracking(budget_usd=5.0),
        PromptInjection(sensitivity="high"),
        PiiDetector(detect=["email", "ssn", "credit_card"]),
    ],
)
result = await agent.run("Hello")

No wrapper agent. No middleware chain. The shields are just capabilities that hook into before_run, after_run, prepare_tools, and before_tool_execute as needed.

The new package ships 10 capabilities: CostTracking, ToolGuard, InputGuard, OutputGuard, AsyncGuardrail for infrastructure, plus PromptInjection, PiiDetector, SecretRedaction, BlockedKeywords, and NoRefusals as zero-dependency content shields.

pydantic-ai-subagents

The subagents library now exposes SubAgentCapability that bundles the subagent toolset and dynamic instructions:

from pydantic_ai import Agent
from subagents_pydantic_ai import SubAgentCapability, SubAgentConfig

agent = Agent(
    "openai:gpt-4.1",
    capabilities=[SubAgentCapability(
        subagents=[
            SubAgentConfig(
                name="researcher",
                description="Researches topics",
                instructions="You are a research assistant.",
            ),
        ],
    )],
)

The capability provides tools via get_toolset() and injects instructions via get_instructions(). It also supports agent spec serialization.

pydantic-ai-summarization

Four capabilities replace the old middleware-based context management:

SummarizationCapability -- triggers LLM summarization when thresholds are reached
SlidingWindowCapability -- zero-cost alternative that discards oldest messages
LimitWarnerCapability -- injects warnings when limits approach
ContextManagerCapability -- full package: token tracking, auto-compression, tool output truncation

from pydantic_ai import Agent
from pydantic_ai_summarization.capability import ContextManagerCapability

agent = Agent(
    "openai:gpt-4.1",
    capabilities=[ContextManagerCapability(max_tokens=100_000)],
)

pydantic-ai-backend

Our filesystem toolkit became ConsoleCapability -- bundling tools, instructions, and permission enforcement:

from pydantic_ai import Agent
from pydantic_ai_backends import ConsoleCapability
from pydantic_ai_backends.permissions import READONLY_RULESET

agent = Agent(
    "openai:gpt-4.1",
    capabilities=[ConsoleCapability(permissions=READONLY_RULESET)],
)

Key Takeaways

1. Delete your abstraction layers. We removed thousands of lines of middleware code. The framework does it better now.

2. Composition is free. Multiple capabilities stack without you writing any merge logic.

3. Agent specs change deployment. Define agent behavior in YAML, deploy by changing a config file.

4. The migration is mechanical. For each middleware hook, there's a direct capability equivalent.

5. Think in capabilities, not agents. The old pattern: build a specialized agent. The new pattern: build a capability, attach it to any agent.

Full RAG Pipeline: 4 Vector Stores, Hybrid Search, and Reranking in One Template

Kacper Włodarczyk — Wed, 25 Mar 2026 01:25:12 +0000

We Added Full RAG to Our Open-Source AI Template: 4 Vector Stores, Hybrid Search, and Reranking

One template, every RAG decision already made — from vector store to reranking strategy.

You know the drill. You want to add RAG to your AI app. So you start: pick a vector database, write an embedding pipeline, figure out chunking, wire up retrieval, add it to your agent as a tool, build a frontend to manage documents...

Three weeks later you have a working prototype. Then someone asks "can we try Qdrant instead of Milvus?" and you realize your vector store is hardcoded in 14 places.

We just shipped v0.2.2 of our open-source full-stack AI template, and RAG was the biggest addition. Not a toy demo — a production pipeline with 4 vector stores, 4 embedding providers, hybrid search, reranking, document versioning, and a management dashboard. All configurable. All swappable.

Here's what we built and why.

I'm Kacper, AI Engineer at Vstorm — an Applied Agentic AI Engineering Consultancy. We've shipped 30+ production AI agent implementations and open-source our tooling at github.com/vstorm-co. Connect with me on LinkedIn.

The Architecture: 5 Steps, Every One Configurable

Every RAG system does the same thing: parse → chunk → embed → store → search. The difference is how many decisions you have to make at each step.

In our template, each step is a pluggable abstraction:

Document Upload
  │
  ├── Parse: PyMuPDF (default) | LlamaParse (130+ formats) | python-docx
  │
  ├── Chunk: recursive (default) | markdown | fixed
  │     └── chunk_size=512, overlap=50 (configurable via env vars)
  │
  ├── Embed: OpenAI | Voyage | Gemini (multimodal) | SentenceTransformers (local)
  │     └── dimensions auto-derived from model name
  │
  ├── Store: Milvus | Qdrant | ChromaDB | pgvector
  │
  └── Search: vector | hybrid (BM25 + vector + RRF) | + reranking (Cohere | CrossEncoder)

You pick your stack during project generation. The template wires everything up. No glue code.

4 Vector Stores, 1 Interface

The biggest design decision was making vector stores swappable. We implemented BaseVectorStore with four backends:

class BaseVectorStore(ABC):
    async def insert_document(self, collection_name: str, document: Document) -> None
    async def search(self, collection_name: str, query: str, limit: int = 4) -> list[SearchResult]
    async def delete_document(self, collection_name: str, document_id: str) -> None
    async def get_collection_info(self, collection_name: str) -> CollectionInfo

Milvus — production-grade, runs as 3 Docker services (etcd + MinIO + Milvus). Best for large-scale deployments. Cosine similarity with IVF_FLAT indexing.

Qdrant — single Docker service, great balance of performance and simplicity. Our default recommendation for most teams.

ChromaDB — embedded mode, zero Docker required. Perfect for prototyping and local development. Just pip install chromadb.

pgvector — uses your existing PostgreSQL. No new infrastructure. HNSW indexing. If you already have Postgres, this is the lowest-friction option.

Switching between them? One environment variable:

# In your .env:
VECTOR_STORE=qdrant    # or: milvus, chromadb, pgvector

The template handles connection strings, Docker services, schema creation, and index configuration automatically.

Hybrid Search: Why Vector-Only Isn't Enough

Pure vector search works well for semantic queries ("documents about building safety"). It fails on exact matches ("find contract #2024-0847") because embeddings don't preserve exact strings.

Our hybrid search combines both:

async def retrieve(self, query: str, collection_name: str, limit: int = 5):
    # Step 1: Vector search (semantic)
    raw_results = await self.store.search(collection_name, query, limit=limit * fetch_multiplier)

    # Step 2: BM25 keyword search
    if self._hybrid_enabled:
        bm25_results = await self._bm25_search(query, collection_name, limit * fetch_multiplier)
        if bm25_results:
            raw_results = self._rrf_fuse(raw_results, bm25_results)

    # Step 3: Rerank (optional)
    if should_rerank and self.rerank_service:
        results = await self.rerank_service.rerank(query=query, results=raw_results, top_k=limit * 2)

    return results[:limit]

The fusion uses Reciprocal Rank Fusion (RRF) — a simple but effective algorithm that combines rankings from multiple sources:

@staticmethod
def _rrf_fuse(vector_results, bm25_results, k=60):
    scores = {}
    for rank, r in enumerate(vector_results):
        key = r.content[:100]
        scores[key] = scores.get(key, 0) + 1.0 / (k + rank + 1)
    for rank, r in enumerate(bm25_results):
        key = r.content[:100]
        scores[key] = scores.get(key, 0) + 1.0 / (k + rank + 1)
    return sorted_by_score(scores)

Enable it with one env var: RAG_HYBRID_SEARCH=true.

Reranking: The Quality Multiplier

Initial retrieval casts a wide net. Reranking narrows it down. We support two options:

Cohere Reranker (API) — the fastest way to improve retrieval quality. Send your results + query, get them re-scored by a model trained specifically for relevance ranking:

response = await self.client.rerank(
    query=query,
    documents=[result.content for result in results],
    model="rerank-v3.5",
    top_n=top_k,
)

CrossEncoder (local) — runs a SentenceTransformers cross-encoder model locally. No API calls, no data leaves your infrastructure:

pairs = [[query, result.content] for result in results]
scores = self.model.predict(pairs)  # Runs locally on CPU/GPU

The pipeline is: retrieve 3× more results than needed → rerank → return top-k. This consistently improves precision without touching your embeddings or vector store.

Document Versioning: SHA256 Dedup

Re-ingesting a document shouldn't create duplicates. Our pipeline uses content hashing:

async def ingest_file(self, filepath, collection_name, replace=True):
    document = await self.processor.process_file(filepath)

    # Check for existing version by source path or content hash
    existing_id = await self._find_existing_by_source(collection_name, source_path)
    if not existing_id:
        existing_id = await self._find_existing_by_hash(collection_name, document.metadata.content_hash)

    # Replace old chunks with new ones
    if existing_id:
        await self.store.delete_document(collection_name, existing_id)

    await self.store.insert_document(collection_name, document)

Google Drive sync? Same logic — changed files get re-embedded, unchanged files skip.

4 Embedding Providers

Provider	Model	Dimensions	API Key?
OpenAI	text-embedding-3-small	1536	Yes
Voyage	voyage-3	1024	Yes
Gemini	gemini-embedding-exp-03-07	3072	Yes
SentenceTransformers	all-MiniLM-L6-v2	384	No (local)

Dimensions are auto-derived from the model name — no manual configuration:

EMBEDDING_DIMENSIONS = {
    "text-embedding-3-small": 1536,
    "voyage-3": 1024,
    "gemini-embedding-exp-03-07": 3072,
    "all-MiniLM-L6-v2": 384,
}

Gemini is the interesting one — it supports multimodal embeddings. Text and images in the same vector space. We use it for image description extraction from PDFs.

The Agent Integration

RAG becomes an agent tool — search_knowledge_base — available to all 5 AI frameworks (Pydantic AI, LangChain, LangGraph, CrewAI, DeepAgents):

async def search_knowledge_base(
    query: str,
    collection: str = "documents",
    collections: list[str] | None = None,  # Multi-collection search
    top_k: int = 5,
) -> str:
    """Search with automatic reranking & hybrid search if enabled."""

Results include source attribution: filename, page number, chunk number, and similarity score. The agent's system prompt instructs it to cite sources with [1], [2] references.

Key Takeaways

RAG is a pipeline of 5 decisions (parse, chunk, embed, store, search) — our template makes each one configurable without code changes
Vector-only search misses exact matches — hybrid (BM25 + vector + RRF) catches both semantic and keyword queries
Reranking is the cheapest quality improvement — 3× over-retrieve + rerank consistently beats tuning embeddings
Document versioning prevents duplicate chunks — SHA256 content hash + source path tracking
One env var switches everything — VECTOR_STORE=pgvector, RAG_HYBRID_SEARCH=true, EMBEDDING_MODEL=voyage-3

Try it yourself

full-stack-ai-agent-template — generates production-ready FastAPI + Next.js AI apps with full RAG pipeline

pip install fastapi-fullstack

Related:

AI Agent Configurator — configure 75+ options visually, download as ZIP
Step-by-step guides — 50 tutorials across 5 frameworks

More from Vstorm's open-source ecosystem:

All our open-source projects — 13 packages for the Pydantic AI ecosystem
awesome-pydantic-ai — curated list of Pydantic AI resources and tools
vstorm.co — our consultancy (30+ AI agent implementations)

If this was useful, follow me on LinkedIn for daily AI agent insights.

It's been a while since my last post, but I'm back with new content for you.

Kacper Włodarczyk — Tue, 17 Mar 2026 12:38:26 +0000

From 0 to Production AI Agent in 30 Minutes — Full-Stack Template with 5 AI Frameworks

Kacper Włodarczyk ・ Mar 17

#ai #programming #python #softwareengineering

From 0 to Production AI Agent in 30 Minutes — Full-Stack Template with 5 AI Frameworks

Kacper Włodarczyk — Tue, 17 Mar 2026 12:37:41 +0000

Every AI project starts the same way.

You need a FastAPI backend. Then authentication — JWT tokens, refresh logic, user management. Then a database — PostgreSQL, migrations, async connections. Then WebSocket streaming for real-time AI responses. Then a frontend — Next.js, state management, chat UI. Then Docker. Then CI/CD.

Three days of boilerplate before you write a single line of AI code.

I've set up this stack from scratch more times than I'd like to admit. After the third project where I copy-pasted the same auth middleware, the same WebSocket handler, the same Docker Compose config — I decided to build a generator that does all of it in one command.

The result: [[full-stack-ai-agent-template]] — an open-source full-stack template with 5 AI frameworks, 75+ configuration options, and a web configurator that generates your entire project in minutes.

614 stars on GitHub. Used by teams at NVIDIA, Pfizer, TikTok, and others. And you can go from zero to a running production AI agent in about 30 minutes.

Let me walk you through exactly how.

Step 1: Open the Web Configurator

Go to oss.vstorm.co/full-stack-ai-agent-template/configurator/.

No CLI installation needed. No pip. Just a browser.

The configurator gives you a visual interface to pick every option for your project. Database, auth, AI framework, background tasks, observability, frontend — all of it. You see the full config before you generate anything.

Alternatively, if you prefer the terminal:

pip install fastapi-fullstack
fastapi-fullstack

This launches the interactive wizard that walks you through the same options.

Step 2: Pick a Preset (or Go Custom)

The template ships with three presets that cover the most common use cases:

Preset	What you get
`--minimal`	Bare FastAPI app — no database, no auth, no extras
`--preset ai-agent`	PostgreSQL + JWT auth + AI agent + WebSocket streaming + conversation persistence + Redis
`--preset production`	Full production setup — Redis, caching, rate limiting, Sentry, Prometheus, Kubernetes

For this walkthrough, I'll use the AI Agent preset with Pydantic AI — the most common starting point for AI applications:

fastapi-fullstack create my_ai_app \
  --preset ai-agent \
  --ai-framework pydantic_ai \
  --frontend nextjs

That single command generates a full-stack project with:

FastAPI backend with async PostgreSQL
JWT authentication with user management
Pydantic AI agent with WebSocket streaming
Conversation persistence (chat history saved to DB)
Redis for caching and sessions
Next.js 15 frontend with React 19 and Tailwind CSS v4
Docker Compose for the full stack
GitHub Actions CI/CD
Logfire observability

Step 3: Look at What You Got

The generated project follows a clean layered architecture — Repository + Service pattern, inspired by real production codebases:

my_ai_app/
├── backend/
│   ├── app/
│   │   ├── main.py              # FastAPI app with lifespan
│   │   ├── api/routes/v1/       # Versioned API endpoints
│   │   ├── core/                # Config, security, middleware
│   │   ├── db/models/           # SQLAlchemy models
│   │   ├── schemas/             # Pydantic schemas
│   │   ├── repositories/        # Data access layer
│   │   ├── services/            # Business logic
│   │   ├── agents/              # AI agents (this is where your code goes)
│   │   └── commands/            # Django-style CLI commands
│   ├── cli/                     # Project CLI
│   ├── tests/                   # pytest test suite
│   └── alembic/                 # Database migrations
├── frontend/
│   ├── src/
│   │   ├── app/                 # Next.js App Router
│   │   ├── components/          # React components (chat UI included)
│   │   ├── hooks/               # useChat, useWebSocket
│   │   └── stores/              # Zustand state management
├── docker-compose.yml
├── Makefile
├── CLAUDE.md                    # AI coding assistant context
└── AGENTS.md                    # Multi-agent project guide

Notice the CLAUDE.md and AGENTS.md files — the generated project is optimized for AI coding assistants like Claude Code, Cursor, and Copilot. It follows progressive disclosure best practices so your AI assistant understands the project structure immediately.

Step 4: Start Everything with Docker

cd my_ai_app
make docker-up        # Backend + PostgreSQL + Redis
make docker-frontend  # Next.js frontend

That's it. Two commands. The entire stack is running:

API: http://localhost:8000
API Docs: http://localhost:8000/docs
Frontend: http://localhost:3000
Admin Panel: http://localhost:8000/admin

If you prefer running without Docker, the template generates a Makefile with shortcuts:

make install       # Install Python + Node dependencies
make docker-db     # Start just PostgreSQL
make db-migrate    # Create initial migration
make db-upgrade    # Apply migrations
make create-admin  # Create admin user
make run           # Start backend
cd frontend && bun dev  # Start frontend

Step 5: Your AI Agent Is Already Working

Open http://localhost:3000, log in, and start chatting. The AI agent is already wired up — WebSocket streaming, conversation history, tool calls — all functional out of the box.

Here's what the generated agent looks like:

# app/agents/assistant.py
from pydantic_ai import Agent, RunContext
from dataclasses import dataclass

@dataclass
class Deps:
    user_id: str | None = None
    db: AsyncSession | None = None

agent = Agent[Deps, str](
    model="openai:gpt-4o-mini",
    system_prompt="You are a helpful assistant.",
)

@agent.tool
async def search_database(ctx: RunContext[Deps], query: str) -> list[dict]:
    """Search the database for relevant information."""
    # Access user context and database via ctx.deps
    ...

Type-safe. Dependency injection built in. Tool calling with full context access. This isn't a toy example — it's the same pattern we use in production at [[Vstorm]].

The WebSocket endpoint handles streaming automatically:

@router.websocket("/ws")
async def agent_ws(websocket: WebSocket):
    await websocket.accept()

    async for event in agent.stream(user_input):
        await websocket.send_json({
            "type": "text_delta",
            "content": event.content
        })

Step 6: Customize the AI Layer

Here's the key insight: everything except the AI agent is production-ready infrastructure that you don't need to touch. Auth works. Database works. Streaming works. Frontend works.

You modify one directory: app/agents/.

Want to change from OpenAI to Anthropic? Update the model string:

agent = Agent[Deps, str](
    model="anthropic:claude-sonnet-4-5",
    system_prompt="You are a helpful assistant.",
)

Want to add a tool? Add a function:

@agent.tool
async def get_weather(ctx: RunContext[Deps], city: str) -> str:
    """Get current weather for a city."""
    async with httpx.AsyncClient() as client:
        resp = await client.get(f"https://api.weather.com/{city}")
        return resp.json()["summary"]

Want to switch to LangChain or CrewAI entirely? Regenerate the project with a different --ai-framework flag. The rest of the stack stays the same.

5 AI Frameworks, One Template

The template supports five AI frameworks, all with the same backend infrastructure:

Framework	Best for	Observability
Pydantic AI	Type-safe agents, dependency injection	Logfire
LangChain	Chains, existing LangChain tooling	LangSmith
LangGraph	Complex multi-step workflows, ReAct agents	LangSmith
CrewAI	Multi-agent crews, role-based agents	LangSmith
DeepAgents	Claude Code-style agentic coding, HITL	LangSmith

You pick the framework when generating the project. The WebSocket streaming, conversation persistence, auth, and frontend all work the same way regardless of which framework you choose.

# Generate with LangGraph
fastapi-fullstack create my_app --preset ai-agent --ai-framework langgraph --frontend nextjs

# Generate with CrewAI
fastapi-fullstack create my_app --preset ai-agent --ai-framework crewai --frontend nextjs

75+ Configuration Options

Beyond AI frameworks, the template covers the full spectrum of production needs:

Databases: PostgreSQL (async), MongoDB (async), SQLite
ORMs: SQLAlchemy, SQLModel
Auth: JWT + refresh tokens, API keys, Google OAuth
Background tasks: Celery, Taskiq, ARQ
Observability: Logfire, LangSmith, Sentry, Prometheus
Infrastructure: Docker, Kubernetes, GitHub Actions, GitLab CI, Traefik, Nginx
Frontend: Next.js 15 with React 19, TypeScript, Tailwind CSS v4, dark mode, i18n
Extras: Redis caching, rate limiting, SQLAdmin panel, webhooks, S3 file storage, RAG with Milvus

Every option is a boolean flag. No Jinja template hacking. No post-generation cleanup. The generator produces clean code that only includes what you selected.

Key Takeaways

The web configurator at oss.vstorm.co lets you visually configure and download a full-stack AI project — no CLI needed.
Three presets (minimal, ai-agent, production) cover 90% of use cases — customize from there.
5 AI frameworks share the same infrastructure — switch frameworks without rewriting your backend.
The generated code is production-grade, not a prototype — layered architecture, async everywhere, type-safe.
You modify app/agents/ and nothing else — auth, streaming, persistence, frontend are done.

Try it yourself

full-stack-ai-agent-template — Production-ready full-stack AI agent template with 5 frameworks and 75+ options.

pip install fastapi-fullstack

Or use the Web Configurator — no installation needed.

More from Vstorm's open-source ecosystem:

All our open-source projects — 13 packages for the Pydantic AI ecosystem
awesome-pydantic-ai — curated list of Pydantic AI resources and tools
vstorm.co — our consultancy (30+ AI agent implementations)

If this was useful, follow me on LinkedIn for daily AI agent insights.

Pydantic-DeepAgents: A Lightweight, Production-Ready Framework for Building Autonomous AI Agents

Kacper Włodarczyk — Mon, 22 Dec 2025 01:19:27 +0000

Inspired by LangChain deepagents — but simpler, type-safe, and with Docker sandboxing built-in

In 2025, autonomous AI agents are no longer just research prototypes — they’re powering real-world automation, code generation tools, data pipelines, and intelligent assistants. However, many popular agent frameworks come with heavy dependencies, complex graphs, and a steep learning curve that makes production deployment challenging.

That’s why we at Vstorm built Pydantic-DeepAgents — a minimal yet powerful open-source framework that extends Pydantic-AI with everything you need to create reliable, production-grade agents.

GitHub repository: https://github.com/vstorm-co/pydantic-deepagents

What makes Pydantic-DeepAgents different?

We were heavily inspired by LangChain’s excellent deepagents project — a clean implementation of “deep agent” patterns including planning loops, tool calling, subagent delegation, and human-in-the-loop workflows.

Instead of reinventing the wheel, we asked: What if we built the same powerful patterns, but fully in the Pydantic-AI ecosystem?

The result is a framework that:

Keeps dependencies lightweight (no LangGraph, no massive ecosystem)
Leverages Pydantic’s native type-safety and validation for structured outputs
Adds production-focused features missing from many alternatives

Core Features

Planning & Reasoning — TodoToolset for autonomous task breakdown and self-correction
Filesystem Access — Full read/write operations with FilesystemToolset
Subagent Delegation — Break complex tasks into specialized subagents (SubAgentToolset)
Extensible Skills System — Define new agent capabilities with simple Markdown prompts (perfect for rapid iteration)
Multiple Backends — In-memory, persistent filesystem, secure DockerSandbox (isolated code execution), and CompositeBackend
File Uploads — Seamless processing of uploaded files via run_with_files() or deps.upload_file()
Context Management — Automatic summarization for long-running conversations
Human-in-the-Loop — Built-in confirmation workflows for critical actions
Streaming Support — Token-by-token responses for responsive UIs
Structured Outputs — Type-safe Pydantic models via output_type

See It in Action

We’ve included a complete full-stack demo application (FastAPI backend + streaming web UI) that demonstrates:

Live agent reasoning traces
File uploads and processing
Human approval steps
Streaming responses

Demo app: https://github.com/vstorm-co/pydantic-deepagents/tree/main/examples/full_app

Quick video walkthrough: https://drive.google.com/file/d/1hqgXkbAgUrsKOWpfWdF48cqaxRht-8od/view?usp=sharing

When to choose Pydantic-DeepAgents?

Choose it when you want:

A clean, maintainable agent architecture without framework bloat
Strong guarantees around data validation and structured responses
Secure execution (Docker sandbox out of the box)
Fast prototyping with Markdown-defined skills
Easy deployment in production environments

It’s particularly great if you’re already using Pydantic-AI, prefer minimalism, or need agents that interact safely with files and external tools.

Get Started Today

pip install pydantic-deep

Check out the repository, star it if you find it useful, and feel free to open issues or PRs — we’d love contributions!

https://github.com/vstorm-co/pydantic-deepagents

We’re excited to see what you build with it.

— Team at Vstorm (https://vstorm.co)

[Python] How to get full url from shortened url

Kacper Włodarczyk — Thu, 16 Nov 2023 00:59:32 +0000

Sometimes when you scrape a website, you may have encountered the fact that the website returns shortened URLs to sources from other websites.

As in this case, for example, https://upflix.pl/r/Qb64Ar this link consists of a domain and some random characters. The way a shortened link works is that it redirects you to another page. Therefore, the status_code that our query returns is 302

Sometimes it happens that we need a full URL to get that can do this with a few lines of Python code and the requests library.

pip install requests

We will use the head method to perform this function
This method is similar to get with the difference that it does not return any content, only headers.

response = requests.head(short_url)

After executing the query, we can check the headers that were returned.
There is information here such as:

date
type of website content
character encoding
FULL LINK and many other information you can see below.

{'Date': 'Thu, 16 Nov 2023 00:43:13 GMT', 'Content-Type': 'text/html; charset=UTF-8', 'Connection': 'keep-alive', 'location': 'https://www.imdb.com/title/tt14060708/', 'vary': 'Origin', 'x-powered-by': 'PHP/7.3.33', 'x-frame-options': 'SAMEORIGIN', 'CF-Cache-Status': 'DYNAMIC', 'Report-To': '{"endpoints":[{"url":"https:\\/\\/a.nel.cloudflare.com\\/report\\/v3?s=bgvCMcMQg1ZkjanlgqzemKUHHthalhb%2FAT72Q58O8a22eFmkeb%2FyeeIMfKkGFwt8WmkMB6dv28F1G2CdH134Kilk%2BcdQNweIZ3O%2FN9KlQf1A2VF%2Bm3yYT89rvjU%3D"}],"group":"cf-nel","max_age":604800}', 'NEL': '{"success_fraction":0,"report_to":"cf-nel","max_age":604800}', 'Strict-Transport-Security': 'max-age=15552000; includeSubDomains; preload', 'X-Content-Type-Options': 'nosniff', 'Server': 'cloudflare', 'CF-RAY': '826bb2ce597ebfda-WAW', 'alt-svc': 'h3=":443"; ma=86400'}

Full code

import requests
from typing import Optional 

def get_full_url(short_url: str) -> Optional[str]
    response = requests.head(short_url)
    if response.status_code == 302:
        headers = response.headers
        return headers["location"]

    return None

Best Youtube channels about Python

Kacper Włodarczyk — Fri, 03 Nov 2023 14:41:21 +0000

Hi, in today's article, I would like to show you the list of Youtube channels about Python programming which I enjoy watching. If you know other channels not presented here, please share them in the comments.

The list is presented in random order!

1. Pixegami

https://www.youtube.com/@pixegami/featured
On this channel, you can find a complete Python course from scratch, tutorials on AWS, Docker, FastAPI, and much more. The materials are of a high standard and everything is well presented. There aren't many movies there, but you'll find something for yourself.
I recommend this movie - https://www.youtube.com/watch?v=Hiabp1GY8fA thanks to it, I easily created a simple website for a client, bought my first domain, and got to know the Vercel website

2. ArjanCodes

https://www.youtube.com/@ArjanCodes/videos
This channel has almost 300 videos and you can find many Python topics here.
I especially recommend older videos on software architecture and the "Code Roasts" series.

3. Coding Crashcourses

https://www.youtube.com/@codingcrashcourses8533/featured
This is a channel created for fans of all language models. Here you will find a lot of guides about the LangChain library and something about FastAPI

4. NeetCode & NeetCodeIO

https://www.youtube.com/@NeetCode/videos
https://www.youtube.com/@NeetCodeIO
Currently one of my favorites, you will find a lot of videos about algorithms and data structures here. If you have a problem with a task on Leetcode, check if it has not already been discussed on this channel.
I also recommend visiting his website - neetcode.io where you will find a roadmap for learning algorithms through tasks on leetcode.

5. Indently

https://www.youtube.com/@Indently/videos
This is my new discovery, the channel has 763 and you can find videos about many programming languages here. Currently, I am starting a series about a not-yet-very popular framework - Flute

6. thenewboston

https://www.youtube.com/@thenewboston/featured
From this channel, I highly recommend the "Python and React" and "Pro Django" series. If you want to deepen your knowledge of Django, this is a great place

7. Django road

https://www.youtube.com/@djangoroad/videos
Short and often interesting videos on various topics from the Django framework

[Python] A Comprehensive Guide to Scraping Instagram Data. How to bypass Instagram login while scraping - Meta Spy

Kacper Włodarczyk — Sat, 28 Oct 2023 21:00:44 +0000

Meta Spy: https://github.com/DEENUU1/meta-spy
Full code is available here: https://pastebin.com/QMmDUZtj
Demo: https://github.com/DEENUU1/meta-spy/blob/main/assets/instagram/imagescraper.gif?raw=true

Info

This article is based on my project which I am still developing - Meta Spy (Facebook Spy before) this week I started to add commands for scraping data from Instagram, my idea is to expand this app for all Meta applications and also add Flet framework as a GUI because typing this commands is making me bored.

How to bypass login ?

Bypassing Instagram's login process might sound like a daunting task, but it's surprisingly straightforward. We'll extract the sessionid key from a browser where we're already logged in and integrate it into the Selenium driver. Here's a step-by-step guide:

Launch Instagram in your browser and press F12 to open the Developer Tools.
In the Developer Tools sidebar, select "Data."
Locate and select the "Cookies" option, then choose cookies for instagram.com.
Copy the sessionid value.

It's time to write some code

Now that we've covered the initial steps, it's time to dive into the code.

Setting Up Chrome Driver Options

To begin, we'll create a class with a static method that simplifies the configuration of the Chrome driver. This class will serve as the foundation for our scraper.




from typing import List  
from time import sleep  
from selenium.webdriver.common.by import By  
from selenium import webdriver  
from selenium.webdriver.support.ui import WebDriverWait  
from selenium.webdriver.chrome.options import Options

class Scraper:  

    @staticmethod  
    def _chrome_driver_configuration() -> Options:  
        chrome_options = Options()  
        chrome_options.add_argument("--disable-notifications")  
        chrome_options.add_argument("--disable-extensions")  
        chrome_options.add_argument("--disable-popup-blocking")  
        chrome_options.add_argument("--disable-default-apps")  
        chrome_options.add_argument("--disable-infobars")  
        chrome_options.add_argument("--disable-web-security")  
        chrome_options.add_argument(  
            "--disable-features=IsolateOrigins,site-per-process"  
        )  
        chrome_options.add_argument(  
            "--enable-features=NetworkService,NetworkServiceInProcess"  
        )  
        chrome_options.add_argument("--profile-directory=Default")  
        chrome_options.add_experimental_option("excludeSwitches", ["enable-logging"])  
        return chrome_options

Implementing the Base Scraper Class

While this tutorial might appear to introduce more classes than necessary, it aligns with our modular approach to project development. This approach allows us to showcase the complete implementation of specific functionalities.




class BaseInstagramScraper(Scraper):  
    def __init__(self, user_id: str, base_url: str) -> None:  
        super().__init__()  
        self._user_id = user_id  
        self._base_url = base_url.format(self._user_id)  
        self._driver = webdriver.Chrome(options=self._chrome_driver_configuration())  
        self._driver.get(self._base_url)  
        self._wait = WebDriverWait(self._driver, 10)

Scoll

Retrieving the full content from Instagram profiles requires scrolling, but it's not as simple as a one-time scroll-and-scrape process. When scrolling through a profile, data appears and disappears dynamically. As only a few rows of images are visible at a time, scrolling to the end and scraping the data is not feasible. To address this, we've created a function that provides a callback mechanism for dynamic content retrieval.

Our standard function scrolls the page down and captures all the visible content. However, in this case, dynamic data retrieval is necessary.



def scroll_page_callback(driver, callback) -> None:  
    """  
    Scrolls the page to load more data from a website    """    try:  
        last_height = driver.execute_script("return document.body.scrollHeight")  
        consecutive_scrolls = 0  

        while consecutive_scrolls < 3:  
            driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")  

            sleep(3)  
            new_height = driver.execute_script("return document.body.scrollHeight")  

            if new_height == last_height:  
                consecutive_scrolls += 1  
            else:  
                consecutive_scrolls = 0  

            last_height = new_height  

            callback(driver)  

    except Exception as e:  
        logs.log_error(f"Error occurred while scrolling: {e}")

Scraping data

Now, let's put all the pieces together and explore the main class responsible for scraping Instagram data.



class ProfileScraper(BaseInstagramScraper):  
    def __init__(self, user_id: str) -> None:  
        super().__init__(user_id, base_url=f"https://www.instagram.com/{user_id}/")  
        self._driver.add_cookie(  
            {  
                "name": "sessionid",  
                "value": "your_sessionid_goes_HERE",  
                "domain": ".instagram.com",  
            }  
        )  
        self._refresh_driver()  

    def _refresh_driver(self) -> None:  
        self._driver.refresh()

The ProfileScraper class inherits from the BaseInstagramScraper, which already includes Chrome driver configurations and more. We add the sessionid cookie to the driver, ensuring that the "value" field contains your sessionid. Next, we call the method:



self._refresh_driver

This method refreshes the driver and correctly loads any newly added cookies.



def extract_images(self) -> List[str]:  
    extracted_image_urls = []  
    try:  

        def extract_callback(driver):  
            img_elements = self._driver.find_elements(  
                By.CLASS_NAME,  
                "x5yr21d.xu96u03.x10l6tqk.x13vifvy.x87ps6o.xh8yej3",  
            )  
            for img_element in img_elements:  
                src_attribute = img_element.get_attribute("src")  
                if src_attribute and src_attribute not in extracted_image_urls:  
                    #print(f"Extracted image URL: {src_attribute}")  
                    extracted_image_urls.append(src_attribute)  
        scroll_page_callback(self._driver, extract_callback)  

    except Exception as e:  
        print(f"An  error occurred while extracting images: {e}")  

    return extracted_image_urls

The core of this class lies in the extract_images method, which returns a list of all scraped image URLs. Inside this method, we find the extract_callback function. It identifies image elements, prints them to the console, and adds them to the extracted_image_url list, checking for duplicates.

Finally, we call the scroll_page_callback function with the Chrome driver and the data extraction function as arguments, ensuring that our scraper works seamlessly.

With this comprehensive guide, you're well-equipped to dive into Instagram data scraping with Meta Spy. As we continue developing this project, expect more features and functionalities that expand its capabilities across all Meta applications. And don't forget, our plans to integrate Flet as a GUI promise to make the experience even more user-friendly. Happy scraping!

Running code




if __name__ == "__main__":  
    scraper = ProfileScraper("sawardega_wataha")  
    data = scraper.extract_images()  
    print(len(data))  
    print(data[0])

Inside ProfileScraper class add a user_id from instagram account.

Results



> python .\main.py
33 # This is a number of scraped urls 
# This is a full url to the scraped image 
https://scontent-waw1-1.cdninstagram.com/v/t51.2885-15/387688415_1338700880368645_3875950289382108239_n.jpg?stp=dst-jpg_e35&efg=eyJ2ZW5jb2RlX3RhZyI6ImltYWdlX3VybGdlbi4xNDQweDE4MDAuc2RyIn0&_nc_ht=scontent-waw1-1.cdnin
stagram.com&_nc_cat=101&_nc_ohc=-w6WTMiiWj4AX-_Qfkt&edm=ACWDqb8BAAAA&ccb=7-5&ig_cache_key=MzIxMTM2ODUyNjYzMDkzMTEzMA%3D%3D.2-ccb7-5&oh=00_AfDoHMVh0dS6msk5yKaW9d81HCeCSgBUJzW82sKRHYRvwQ&oe=65433911&_nc_sid=ee9879

[Python] Project ideas for every level of advancement

Kacper Włodarczyk — Fri, 27 Oct 2023 20:38:12 +0000

This list contains 6 project ideas that I made while learning programming. I can't say whether these projects will be easy for you or what tools you should use, I'm just sharing my experiences and hope they inspire you.
They are listed in a random order.

1. Space Catalog

Stack: Python, Tkinter
Source code

This was my first "bigger" project that I created over a year ago. It's a simple GUI application that allows users to access information about planets and search for "Image of the Day" from the NASA API.
I used Tkinter to build the GUI. However, if I were to create something similar today, I would use Flet, which is a relatively new framework for building GUI applications on Windows, Linux, macOS, Android, and iOS.
Of course, you don't have to create an application about space; it could be about car brands, plants, or anything else.

2. Weather Music

Stack: Python, Django, HTML, Bootstrap, CSS, Docker, PostgreSQL
Source code

I believe this was my first Django project. This program retrieves the user's location and, with the help of an external API, provides the current weather for that location.
However, it seemed too simple to me, so I expanded the program to include access to Spotify playlists. The algorithm, though simple, selects appropriate playlists for the user based on the weather conditions.

3. OLX Analytics

Stack: Python, Flask, HTML, CSS, Bootstrap, Docker, SQLite, APScheduler
Source code

OLX is a Polish platform for classified ads. They have an open API (more about that in the next article) that allowed me to easily scrape and parse data about apartment listings for sale or rent. This enables users to search for new offers and access other interesting statistics.
I also used APScheduler to automatically send emails with new offers to users.

4. Wallpaper Manager

Stack: Python, Tkinter
Source code

I never finished this app, but it has all the necessary functionalities.
It was inspired by "wallpaper engine," and that's why I'm including this project here.
You don't need to create something entirely new. Just take a moment, look at the apps you currently use, and try to recreate them. The point of personal projects is to practice, encounter new challenges, and learn new things.

5. Facebook Spy

I've already written an article about this project, so check it out here -> Article.

6. FJob

Stack: Python, Selenium, BeautifulSoup, Rest Framework, Celery, Django Celery Beat, PostgreSQL, Docker, Docker Compose, React (JavaScript + Vite)
Source code

Well... 356 commits, but there's still a lot of work to be done.

I'm including this project here to show you how different programming elements can be combined.
The core of this project consists of web scrapers that collect data from websites such as OLX, Pracujpl, nofluffjobs, justjoinit, etc.
This data is then stored in a database and accessed via a REST API created using the Django Rest Framework.
The user interface is built using React and JavaScript.

This application may seem extensive, but it's essentially a collection of interconnected pieces.
If you're interested in data collection from websites, think about the various ways you can use that data. It can be used for training artificial intelligence, conducting analyses, or helping people find jobs by consolidating all the data in one place.

The only Celery & Django Tutorial you need

Kacper Włodarczyk — Wed, 18 Oct 2023 15:18:00 +0000

In my life, I watched a lot of tutorials about Celery & Django configuration but I was always getting some errors.

Today I am gonna show you the easy way to add Celery and Redis to your Django project.
This tutorial is based on one of my projects available on GitHub MyFridge.

About Celery and Redis

Celery

Celery is a distributed task queue system that allows you to run time-consuming tasks asynchronously. With Celery, you can decouple long-running or resource-intensive processes from your main application, making your application more responsive and efficient. Celery supports various message brokers like Redis, RabbitMQ, and more, but in this article, we'll focus on using Celery with Redis.

Redis

Redis is an open-source, in-memory data structure store that can be used as a message broker for Celery. It excels at handling high-throughput, low-latency tasks and provides persistent data storage. In the context of Celery, Redis acts as a message broker, passing messages between the main application and the worker processes that execute tasks in the background.

Final project structure (this structure includes other content, we gonna focus only on a few elements)

As you can see my project in Django is called - myfridge but yours probably will have another name so you need to change all 'myfridge' to your project name (inside files:

celery.py
Dockerfile
docker-compose.yml )

Installation and configuration

Install packages

First, you need to install celery and Redis packages

pip install celery Redis

Add this packages to requirements.txt

pip freeze > requirements.txt

Create a celery.py file inside your Django project (the same place where settings.py is)

celery.py

from __future__ import absolute_import, unicode_literals
import os
from celery import Celery
from Django.conf import settings


os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myfridge.settings") # Change 'myfridge' to your project name 
app = Celery("myfridge") # Change 'myfridge' to your project name
app.config_from_object(settings, namespace="CELERY")
app.autodiscover_tasks()

Configure __ init __ .py In the same directory where you created celery.py, there is a file called '__ init__ .py' You need to paste this code inside this file

__ init __ .py

from .celery import app as celery_app

__all__ = ("celery_app",)

Edit settings.py Inside settings.py file you need to configure your Celery broker, result backend, and other important things. For me, it looks like this

settings.py

CELERY_BROKER_URL = "redis://redis:6379/0"
CELERY_RESULT_BACKEND = "redis://redis:6379/0"
CELERY_ACCEPT_CONTENT = ["application/json"]
CELERY_TASK_SERIALIZER = "json"
CELERY_RESULT_SERIALIZER = "json"

Docker configuration Now to run Celery, redis, and Django we need to use Docker.

First of all, in your main directory create a 'config' directory and inside it create a directory called 'Django' and then inside it create a file called Dockerfile Note that D must be an uppercase

Dockerfile

FROM python:3.11

ENV PYTHONUNBUFFERED 1

WORKDIR /app

COPY requirements.txt.

RUN pip install -r requirements.txt

COPY ./myfridge /app/ # Change 'myfridge' to your project name

Then inside the main directory (where config and Django project is) create a file called docker-compose.yml

In my example it's called docker-compose.dev.yml but you need to name it docker-compose.yml

docker-compose.yml


version: "3"

services:
    db:
        hostname: db
        image: postgres:15
        container_name: myfridge-db-dev 
        volumes:
            - ./data/db:/var/lib/postgresql/data
        environment:
            - POSTGRES_DB=myfridge
            - POSTGRES_USER=myfridge
            - POSTGRES_PASSWORD=myfridge123
        ports:
            - "5432:5432"

    web:
        hostname: web
        build:
            context: .
            dockerfile: ./config/django/Dockerfile
        container_name: myfridge-web-dev # Change 'myfridge' to your project name
        command: python manage.py runserver 0.0.0.0:8000
        volumes:
            - ./myfridge:/app # Change 'myfridge' to your project name
        ports:
            - "8000:8000"
        depends_on:
            - db
            - redis
            - celery
        env_file:
            - .env

    redis:
        image: redis:latest
        container_name: myfridge-redis-dev # Change 'myfridge' to your project name
        ports:
            - "6379:6379"

    celery:
        build:
            context: .
            dockerfile: ./config/django/Dockerfile
        container_name: myfridge-celery-dev # Change 'myfridge' to your project name
        command: celery -A myfridge.celery worker -l info # Change 'myfridge' to your project name
        volumes:
            - ./myfridge:/app/ # Change 'myfridge' to your project name
        depends_on:
            - db
            - redis

And thats all for our configuration, note that you need to change all 'myfridge' to you project name

To run Django project with Docker you need to use PostgreSQL database
Check this tutorial Docker With Django And PostgreSQL Tutorial

Example 1

Inside your django application create a file called task.py

task.py


from celery import shared_task

@shared_task()
def add(x, y):
    return x + y

As you can see to make a task you need to add @shared_task() decorator to your function

Call this task inside your view

views.py


from .task import add

def add_view(request):
    result = add.delay(4, 6)
    return HttpResponse(result)

To run 'add' function as a task add .delay() method

Example 2

Inside your django application create a file called task.py

Create some function that should do somethings

send_email.py

def send_email(email, subject, message):
    print(f"Sending email to {email}")

Of course this function doesn't do anything but it's just an example

Then in task.py

task.py

from .send_email import send_email
from celery import shared_task

@shared_task()
def send_email_task(email, subject, message):
    send_email(email, subject, message)

Before our function task, we need to add the decorator

@shared_task()

And then inside that task call our function

Running a task You can you this task inside your forms, views, commands, etc In this example, I am gonna use it inside the registration form This code is not import for you, you don't need to understand it.

forms.py

from django import forms
from django.contrib.auth.forms import AuthenticationForm
from .models import CustomUser
from .task import send_email_task


class CustomUserRegistration(forms.ModelForm):
    username = forms.CharField(widget=forms.TextInput(attrs={"class": "form-control"}))
    email = forms.EmailField(widget=forms.EmailInput(attrs={"class": "form-control"}))
    password = forms.CharField(
        widget=forms.PasswordInput(attrs={"class": "form-control"})
    )
    password_repeat = forms.CharField(
        widget=forms.PasswordInput(attrs={"class": "form-control"})
    )

    class Meta:
        model = CustomUser
        fields = ("username", "email", "password", "password_repeat")

    def clean_email(self):
        email = self.cleaned_data.get("email")
        if CustomUser.objects.filter(email=email).exists():
            raise forms.ValidationError("Email already exists")
        return email

    def clean_password_repeat(self):
        password = self.cleaned_data.get("password")
        password_repeat = self.cleaned_data.get("password_repeat")
        if password != password_repeat:
            raise forms.ValidationError("Passwords don't match")
        return password_repeat

    def send_email(self, message):
        send_email_task.delay(
            self.cleaned_data.get("email"),
            subject="Activate your account",
            message=message,
        )

Take a look at the last method 'send_email'
Inside that method I am calling for our task and to run it I am using .delay method
This allows us to run it as a celery task

views.py



class RegisterUserView(FormView):
    form_class = CustomUserRegistration
    template_name = "register.html"
    success_url = reverse_lazy("users:success_register")

    def form_valid(self, form):
        user = form.save(commit=False)
        user.is_active = False
        user.set_password(form.cleaned_data["password"])
        user.save()
        form.send_email(
            message=render_to_string(
                "acc_activate_email.html",
                {
                    "user": user,
                    "domain": get_current_site(self.request).domain,
                    "uid": urlsafe_base64_encode(force_bytes(user.pk)),
                    "token": account_activation_token.make_token(user),
                },
            )
        )
        return super().form_valid(form)

Inside RegisterUserView I am using this form and I am able to use the method send_email

Facebook SPY - Python CLI Tools for scraping Facebook

Kacper Włodarczyk — Fri, 13 Oct 2023 20:26:42 +0000

I would like to share with you one of the biggest projects I have ever worked on.

Facebook Spy is a tool for scraping data from Facebook profiles, pages, and search results.
For example, you can scrape all posts from a given Facebook account, and download images and videos.

Info!

For more details and visualization check README or Documentation

Repository: Facebook Spy on GitHub
Documentation: Facebook Spy Documentation

Facebook Spy offers the following functionalities:

Login: Perform a secure two-step verification process to log in to your Facebook account with enhanced security settings or log in to your Facebook account using the default login method.
Data Scraping: Retrieve details such as friend lists, images, recent locations, videos, reels, reviews, posts, likes, groups, events, and more.
Local Web Application: Run a local web application to browse scraped data, create notes for specific user profiles, and easily search for details on the web.
Video Downloader: Download all scraped videos from a Facebook account or simply by adding the provided URL.
Visualize Connections: Create a graphical representation of connections between different Facebook profiles based on their friendships.
Utilize an Open-Source Language Model: Use a free open-source language model to generate a concise summary of a Facebook user's information based on the scraped data.
Friend Crawler: Initiate a friend crawler for a specified Facebook account, gather data about friends, and continue the process for subsequent users in the queue.
Data Export: Save scraped data for a specified Facebook user to a PDF file for documentation and analysis.
Parallel Scraping: Run scrapers in parallel to expedite the data collection process.
Data Storage: Save all scraped data to JSON files and a database.

DEV Community: Kacper Włodarczyk

Pydantic Deep Agents 0.3.3: ACP, Thinking, Lifecycle Hooks, and Opinionated Defaults

ACP: Your Agent in Any Editor

Subagents Are Now Deep Agents by Default

Thinking Enabled by Default

Anthropic Prompt Caching — On by Default

5 New Lifecycle Hooks

Skills as Slash Commands

Other Notable Changes

Opinionated Defaults

Get Started

Pydantic AI Capabilities, Hooks & Agent Specs - What Changed and How Our Libraries Migrated

What Are Capabilities?

What Are Hooks?

What Are Agent Specs?

How Our Libraries Migrated

pydantic-ai-middleware to pydantic-ai-shields

pydantic-ai-subagents

pydantic-ai-summarization

pydantic-ai-backend

Key Takeaways

Links

Full RAG Pipeline: 4 Vector Stores, Hybrid Search, and Reranking in One Template

We Added Full RAG to Our Open-Source AI Template: 4 Vector Stores, Hybrid Search, and Reranking

The Architecture: 5 Steps, Every One Configurable

4 Vector Stores, 1 Interface

Hybrid Search: Why Vector-Only Isn't Enough

Reranking: The Quality Multiplier

Document Versioning: SHA256 Dedup

4 Embedding Providers

The Agent Integration

Key Takeaways

Try it yourself

It's been a while since my last post, but I'm back with new content for you.

From 0 to Production AI Agent in 30 Minutes — Full-Stack Template with 5 AI Frameworks

Kacper Włodarczyk ・ Mar 17

From 0 to Production AI Agent in 30 Minutes — Full-Stack Template with 5 AI Frameworks

Step 1: Open the Web Configurator

Step 2: Pick a Preset (or Go Custom)

Step 3: Look at What You Got

Step 4: Start Everything with Docker

Step 5: Your AI Agent Is Already Working

Step 6: Customize the AI Layer

5 AI Frameworks, One Template

75+ Configuration Options

Key Takeaways

Try it yourself

Pydantic-DeepAgents: A Lightweight, Production-Ready Framework for Building Autonomous AI Agents

What makes Pydantic-DeepAgents different?

Core Features

See It in Action

When to choose Pydantic-DeepAgents?

Get Started Today

[Python] How to get full url from shortened url

Full code

Best Youtube channels about Python

1. Pixegami

2. ArjanCodes

3. Coding Crashcourses

4. NeetCode & NeetCodeIO

5. Indently

6. thenewboston

7. Django road

[Python] A Comprehensive Guide to Scraping Instagram Data. How to bypass Instagram login while scraping - Meta Spy

Info

How to bypass login ?

It's time to write some code

Setting Up Chrome Driver Options

Implementing the Base Scraper Class

Scoll

Scraping data

Running code

Results

[Python] Project ideas for every level of advancement

1. Space Catalog

2. Weather Music

3. OLX Analytics

4. Wallpaper Manager

5. Facebook Spy

6. FJob