DEV Community: Serhii Kalyna

n8n AI Automation: Build Intelligent Workflows with LLMs (2026)

Serhii Kalyna — Mon, 25 May 2026 12:31:29 +0000

Originally published at kalyna.pro

n8n is the open-source workflow automation platform that has quietly become the go-to choice for developers who want Zapier-level convenience without vendor lock-in. In 2026, its built-in AI nodes — combined with direct API access to Claude, GPT-4o, and Gemini — make it possible to build genuinely intelligent workflows: email summarizers, Slack Q&A bots, customer feedback classifiers, and multi-tool agents that plan and act autonomously.

What is n8n?

n8n (n-eight-n) is a fair-code licensed workflow automation tool. Like Zapier or Make, it connects apps and services through a visual canvas. Unlike them, you can self-host it for free, write custom JavaScript or Python in Code nodes, and call any HTTP API directly — including LLM providers.

Core concepts:

Nodes — individual steps: trigger on a Gmail message, call an HTTP endpoint, write to a Google Sheet
Workflows — a directed graph of nodes; data flows as JSON between them
Triggers — the event that starts a workflow: webhook, schedule, app event, or manual run
Credentials — stored API keys and OAuth tokens, configured once and reused in any node
Expressions — {{ $json.fieldName }} syntax to reference data from previous nodes

n8n is available as n8n Cloud (hosted, from $20/month) or as a free self-hosted Docker container. The codebase is released under a fair-code license: free to self-host for individuals and small teams.

Setting Up n8n with Docker

Create a docker-compose.yml and run docker compose up -d:

version: "3.8"

services:
  n8n:
    image: n8nio/n8n:latest
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=changeme
      - WEBHOOK_URL=http://localhost:5678/
      - GENERIC_TIMEZONE=Europe/Kyiv
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:

Open http://localhost:5678. The n8n_data volume persists all workflows and credentials across restarts. For production: use a reverse proxy with HTTPS, set N8N_ENCRYPTION_KEY, and change the default password.

Your First AI Workflow: Email Summarizer

Three nodes — Gmail Trigger → HTTP Request (Claude) → Gmail Send:

Gmail Trigger node — On Message Received, filtered to label needs-summary. Passes subject, sender, body as $json.
HTTP Request node — POST https://api.anthropic.com/v1/messages, header x-api-key + anthropic-version: 2023-06-01, body: {"model": "claude-sonnet-4-6", "max_tokens": 256, "messages": [{"role": "user", "content": "Summarise this email in 3 bullet points: {{ $json.text }}"}]}. Reply is at content[0].text.
Gmail node (Reply) — thread ID: {{ $('Gmail Trigger').item.json.id }}, body: {{ $json.content[0].text }}.

Connect, activate, send a test email. The summary reply arrives within seconds.

Calling Claude API in n8n

n8n ships a built-in Anthropic node (v1.30+). For full control, use the HTTP Request node:

Method: POST
URL: https://api.anthropic.com/v1/messages
Header — x-api-key: your Anthropic API key (store as Header Auth credential)
Header — anthropic-version: 2023-06-01
Header — content-type: application/json
Body (JSON): {"model": "claude-sonnet-4-6", "max_tokens": 1024, "messages": [{"role": "user", "content": "{{ $json.prompt }}"}]}

Read the reply with {{ $json.content[0].text }}. For a full walkthrough including tool use, vision, and extended thinking in n8n, see the n8n Claude Automation Guide.

Build a Slack AI Bot

Four nodes — Slack Trigger → IF (filter bots) → HTTP Request (Claude) → Slack reply:

Slack Trigger — Message Posted to Channel in #ask-ai, outputs text and channel
IF node — condition: {{ $json.bot_id }} is empty (prevents reply loops)
HTTP Request (Claude) — prompt: You are a helpful team assistant. Answer concisely: {{ $('Slack Trigger').item.json.text }}
Slack node — Post Message, reply in thread using {{ $('Slack Trigger').item.json.ts }}

Add a Code node before the LLM call to fetch vector database chunks for a five-node RAG-powered Q&A bot over your documentation.

AI Data Processing Pipeline

Webhook → validate → Claude classify → route → Google Sheets:

Webhook — POST endpoint receives customer_id, message, rating
Code node — validate and normalise the payload
HTTP Request (Claude) — prompt: Classify into BUG, FEATURE_REQUEST, COMPLAINT, PRAISE, or OTHER. Extract product area. Respond JSON only: {"category": "...", "product_area": "..."}.
Switch node — BUG → Jira; COMPLAINT → Zendesk; PRAISE → Slack #wins
Google Sheets — append all items: timestamp, customer_id, message, rating, category

n8n AI Agent (2026)

The AI Agent node (stable since v1.35) implements the plan-act-observe loop natively:

Plan — Claude receives the goal and tool descriptions, outputs a structured tool call
Act — n8n executes the tool (HTTP request, search, code) and captures the result
Observe — the result is appended to the conversation context
Repeat — Claude calls the next tool or outputs a final answer (max iterations: 10)

Tools to attach: Web Search (SerpAPI/Tavily), HTTP Request (internal APIs), Calculator, Google Calendar.

Practical use cases: competitive research, automated report generation, code review bots, customer support agents with live data lookup.

n8n vs Zapier vs Make

	n8n	Zapier	Make
Pricing	Free self-hosted	$20+/mo (task-based)	$9+/mo (op-based)
AI nodes	Agent node + any LLM API	OpenAI only (limited)	OpenAI module only
Self-hosting	Yes (Docker/Kubernetes)	No	No
Code execution	JS + Python, full npm/PyPI	Limited JS	None
Integrations	400+ native + HTTP Request	6,000+ native	1,600+ native

For AI-heavy workflows or self-hosting, n8n is the clear choice. Zapier leads on integration breadth; Make is a strong middle ground for non-developers needing visual routing.

Best Practices

Error Trigger node — dedicated error workflow sends Slack alerts with workflow name, node, and error message
Wait node — 1–2 second delay between LLM batch calls prevents 429 rate-limit errors
Manual Trigger for development — build and debug without touching live sources; add the production trigger when stable
Split In Batches — process 10–50 items at a time to keep memory low and failures recoverable
Pin data — right-click node output to freeze test inputs; subsequent runs use pinned data, not live APIs
Prompt versioning — store system prompts in n8n Variables, not hardcoded in node parameter fields
Credential scoping — always use n8n Credentials; never put API keys in expressions or Code nodes

Summary

n8n is a self-hostable, fair-code automation platform with native AI Agent, Anthropic, and OpenAI nodes
Docker Compose setup runs on port 5678 in under five minutes; n8n Cloud is the managed alternative
Email summariser, Slack bot, and classification pipeline all follow the same three-to-five node structure
The AI Agent node runs a plan-act-observe loop natively — wire in tools and let Claude decide how to use them
n8n beats Zapier and Make on AI depth, self-hosting freedom, and code execution
Error Trigger + Wait + Split In Batches make AI workflows production-ready

Further reading:

Pinecone Tutorial: Getting Started with Vector Search in Python (2026)

Serhii Kalyna — Mon, 25 May 2026 12:22:22 +0000

Originally published at kalyna.pro

Pinecone is a managed vector database built for production-scale similarity search. Unlike self-hosted alternatives, it handles infrastructure, replication, and scaling automatically. In this tutorial you will create a Pinecone index from scratch, generate embeddings with Sentence Transformers, upsert vectors with metadata, run semantic queries, and wire up a full RAG pipeline with the Claude API.

Common use cases: semantic search, RAG, recommendation systems, and duplicate detection.

Prerequisites

Python 3.8+ installed
A free Pinecone account at pinecone.io — free tier includes 2 GB storage and one serverless index
Your Pinecone API key from the Pinecone console

Install the required packages:

pip install pinecone sentence-transformers

Create Your First Index

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="YOUR_PINECONE_API_KEY")

# Create a serverless index (AWS us-east-1 is available on the free tier)
pc.create_index(
    name="demo",
    dimension=384,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1"),
)

# Connect to the index
index = pc.Index("demo")
print(index.describe_index_stats())

Guard against re-creating an existing index:

existing = [i.name for i in pc.list_indexes()]
if "demo" not in existing:
    pc.create_index(
        name="demo",
        dimension=384,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
    )

index = pc.Index("demo")

Generate Embeddings

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")

texts = [
    "Python is a high-level programming language.",
    "Machine learning models require training data.",
    "Vector databases store embeddings for similarity search.",
    "LLMs generate text by predicting the next token.",
    "Pinecone is a managed vector database for production use.",
]

embeddings = model.encode(texts)
print(f"Shape: {embeddings.shape}")  # (5, 384)

model.encode() returns a NumPy array of shape (n_texts, 384). Call .tolist() on each row before upserting into Pinecone.

Upsert Vectors

vectors = [
    {
        "id": f"doc{i}",
        "values": embeddings[i].tolist(),
        "metadata": {"text": texts[i], "source": "docs"},
    }
    for i in range(len(texts))
]

index.upsert(vectors=vectors)
print(index.describe_index_stats())

For large datasets, batch in chunks of 100:

def upsert_in_batches(index, vectors, batch_size=100):
    for i in range(0, len(vectors), batch_size):
        batch = vectors[i : i + batch_size]
        index.upsert(vectors=batch)
        print(f"  Upserted {min(i + batch_size, len(vectors))}/{len(vectors)}")

Query Vectors

query_text = "What is a vector database?"
query_emb = model.encode([query_text])[0].tolist()

results = index.query(
    vector=query_emb,
    top_k=3,
    include_metadata=True,
)

for match in results["matches"]:
    print(f"Score: {match['score']:.4f}  |  {match['metadata']['text']}")

Filter by metadata at query time:

results = index.query(
    vector=query_emb,
    top_k=5,
    include_metadata=True,
    filter={"source": {"$eq": "docs"}},
)

Full Semantic Search Example

from pinecone import Pinecone, ServerlessSpec
from sentence_transformers import SentenceTransformer

PINECONE_API_KEY = "YOUR_PINECONE_API_KEY"
INDEX_NAME = "semantic-search-demo"

articles = [
    "Pinecone is a managed vector database optimised for high-speed similarity search.",
    "ChromaDB is an open-source vector store that runs locally without any API key.",
    "FAISS is a Facebook AI library for efficient exact and approximate nearest neighbour search.",
    "Sentence Transformers convert text to dense embedding vectors for semantic similarity.",
    "RAG combines retrieval with generation to ground LLM answers in real documents.",
    "Python is the dominant language for machine learning and AI development in 2026.",
    "Claude is Anthropic's family of AI assistants based on Constitutional AI training.",
    "LangChain provides tools for composing LLM pipelines using a pipe-operator syntax.",
    "LlamaIndex specialises in document ingestion and advanced retrieval for RAG systems.",
    "Cosine similarity measures the angle between two vectors, ignoring their magnitude.",
]

model = SentenceTransformer("all-MiniLM-L6-v2")
embeddings = model.encode(articles)

pc = Pinecone(api_key=PINECONE_API_KEY)
existing = [i.name for i in pc.list_indexes()]
if INDEX_NAME not in existing:
    pc.create_index(
        name=INDEX_NAME,
        dimension=384,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
    )

index = pc.Index(INDEX_NAME)

vectors = [
    {"id": f"article{i}", "values": embeddings[i].tolist(), "metadata": {"text": articles[i]}}
    for i in range(len(articles))
]
index.upsert(vectors=vectors)
print(f"Indexed {len(articles)} articles\n")

queries = [
    "Which vector database works offline?",
    "How does semantic search differ from keyword search?",
    "What tool helps build RAG pipelines?",
]

for query in queries:
    qvec = model.encode([query])[0].tolist()
    results = index.query(vector=qvec, top_k=2, include_metadata=True)
    print(f"Query: {query}")
    for r in results["matches"]:
        print(f"  [{r['score']:.3f}] {r['metadata']['text']}")
    print()

Pinecone + RAG with Claude

import anthropic
from pinecone import Pinecone
from sentence_transformers import SentenceTransformer

pc = Pinecone(api_key="YOUR_PINECONE_API_KEY")
index = pc.Index("semantic-search-demo")
model = SentenceTransformer("all-MiniLM-L6-v2")
claude = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from env


def rag_query(question: str, top_k: int = 3) -> str:
    qvec = model.encode([question])[0].tolist()
    results = index.query(vector=qvec, top_k=top_k, include_metadata=True)
    context = "\n".join(r["metadata"]["text"] for r in results["matches"])

    prompt = (
        f"Answer the question using only the context below.\n\n"
        f"Context:\n{context}\n\n"
        f"Question: {question}"
    )

    message = claude.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,
        messages=[{"role": "user", "content": prompt}],
    )
    return message.content[0].text


print(rag_query("What is the difference between Pinecone and ChromaDB?"))

Install the Claude SDK: pip install anthropic. For a deeper RAG walkthrough, see the RAG Tutorial with Python.

Pinecone vs ChromaDB

	Pinecone	ChromaDB
Type	Managed cloud service	Open source, self-hosted
Scale	Billions of vectors	Tens of millions (single node)
Cost	Free tier + paid plans from $70/mo	Free to self-host
Setup	API key, no infra	pip install, runs in-process
Best for	Production SaaS, large scale	Local dev, prototypes, privacy

Pinecone — managed, scalable, SLA-backed. No ops required.
ChromaDB — open source, local, zero cost. Full data control.
Both support metadata filtering and cosine/dot/euclidean metrics.

See the ChromaDB Tutorial and Vector Databases Comparison (2026) for a full breakdown.

Pinecone Pricing

Free (Starter) — 2 GB storage, 1 serverless index, unlimited queries within the free allocation. No credit card required.
Standard — from $70/month — multiple indexes, higher storage, dedicated support SLA.
Enterprise — $100+/month (custom) — private clusters, VPC peering, SSO, custom SLAs.

Costs are measured in read units (RU) and write units (WU). Check the Pinecone pricing page for current numbers.

Summary

Create a Pinecone index with pc.create_index() specifying dimension and metric to match your embedding model.
Use all-MiniLM-L6-v2 from Sentence Transformers for free, accurate local embeddings (384 dimensions).
Upsert vectors with metadata using index.upsert(vectors=[...]) and batch in chunks of 100.
Query by natural language with index.query(vector=..., top_k=5, include_metadata=True).
Add a filter dict to restrict results by metadata fields at query time.
Combine Pinecone retrieval with claude-sonnet-4-6 for a production RAG pipeline.
Choose Pinecone for managed, scalable production; choose ChromaDB for local dev and cost-sensitive projects.

Further reading:

Claude API Tutorial: Complete Beginner's Guide (Python, 2026)

Serhii Kalyna — Mon, 25 May 2026 12:16:58 +0000

Originally published at kalyna.pro

The Claude API gives you direct access to Anthropic's language models from any Python application. Whether you want to generate text, analyze images, stream responses token by token, or wire up tools so Claude can call your own functions — all of it goes through the same client.messages.create() call. This tutorial walks through every major feature with working code, from your first "Hello!" to a full tool-use loop.

Prerequisites

You need Python 3.8 or later and an Anthropic API key. If you do not have a key yet, follow the step-by-step guide at How to Get a Claude API Key — it takes about two minutes.

export ANTHROPIC_API_KEY="sk-ant-..."   # add to ~/.bashrc or ~/.zshrc

Installation and First Call

pip install anthropic

Make your first API call — the SDK reads ANTHROPIC_API_KEY automatically:

from anthropic import Anthropic

client = Anthropic()

msg = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)

print(msg.content[0].text)

The Messages API

Every call to client.messages.create() accepts the same core parameters:

model — the Claude model to use (e.g. "claude-sonnet-4-6")
max_tokens — the upper limit on output tokens
messages — a list of turn objects with role ("user" or "assistant") and content
system — an optional system prompt string

The content field can be a plain string or a list of content blocks — objects with a type field ("text", "image", "tool_use", "tool_result"). The response exposes msg.content[0].text, msg.stop_reason, and msg.usage for token counts.

Your First Chat App

The Messages API is stateless. Append each exchange to the messages list to maintain conversation history:

from anthropic import Anthropic

client = Anthropic()
conversation = []

print("Chat with Claude (type 'quit' to exit)\n")

while True:
    user_input = input("You: ").strip()
    if user_input.lower() in ("quit", "exit", "q"):
        break
    if not user_input:
        continue

    conversation.append({"role": "user", "content": user_input})

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=conversation,
    )

    assistant_text = response.content[0].text
    conversation.append({"role": "assistant", "content": assistant_text})

    print(f"Claude: {assistant_text}\n")

Streaming Responses

Use client.messages.stream() to display tokens as they arrive:

from anthropic import Anthropic

client = Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain quantum entanglement simply."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

print()

Call stream.get_final_message() after the loop if you need the complete Message object.

Analyzing Images with Vision

Pass images as base64-encoded content blocks:

import base64
from anthropic import Anthropic

client = Anthropic()

with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data,
                    },
                },
                {
                    "type": "text",
                    "text": "Describe what you see in this image.",
                },
            ],
        }
    ],
)

print(response.content[0].text)

Supported types: image/jpeg, image/png, image/gif, image/webp. You can also pass images by URL using "type": "url".

Tool Use (Function Calling)

Define tools with JSON Schema, handle stop_reason == "tool_use", and return results as tool_result blocks:

from anthropic import Anthropic

client = Anthropic()

tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name, e.g. 'Kyiv'"},
            },
            "required": ["city"],
        },
    }
]


def get_weather(city: str) -> str:
    return f"The weather in {city} is 22°C and sunny."


messages = [{"role": "user", "content": "What's the weather in Kyiv?"}]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

if response.stop_reason == "tool_use":
    tool_block = next(b for b in response.content if b.type == "tool_use")
    tool_result = get_weather(**tool_block.input)

    messages.append({"role": "assistant", "content": response.content})
    messages.append({
        "role": "user",
        "content": [
            {
                "type": "tool_result",
                "tool_use_id": tool_block.id,
                "content": tool_result,
            }
        ],
    })

    final = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    print(final.content[0].text)
else:
    print(response.content[0].text)

System Prompts

The system parameter sets a persistent instruction outside the turn list:

from anthropic import Anthropic

client = Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=(
        "You are a senior Python engineer. "
        "Always respond with concise, production-quality code. "
        "Prefer explicit error handling and type hints."
    ),
    messages=[{"role": "user", "content": "Write a function to retry a failed HTTP request."}],
)

print(response.content[0].text)

Tips: be specific about format, state constraints positively, keep the system prompt stable across turns, and use prompt caching on long system prompts to cut costs.

Choosing a Model

claude-opus-4-7 — most capable; best for complex reasoning and multi-step agentic tasks
claude-sonnet-4-6 — balanced quality, cost, and speed; the right default for most apps
claude-haiku-4-5 — fastest and cheapest; ideal for high-volume, real-time, or extraction tasks

All three support the same API surface. Start with claude-sonnet-4-6 and adjust from there.

Summary

Install with pip install anthropic; the SDK reads ANTHROPIC_API_KEY automatically
Every feature goes through client.messages.create()
Multi-turn chat: append each exchange to the messages list
Streaming: use client.messages.stream() and iterate stream.text_stream
Vision: pass base64-encoded images as content blocks
Tool use: define tools with JSON Schema, handle tool_use stop reason, return tool_result blocks
System prompts: use the system parameter outside the messages list
Default to claude-sonnet-4-6; upgrade to Opus for quality, downgrade to Haiku for speed

Further reading:

Best AI Coding Tools in 2026: Developer's Honest Guide

Serhii Kalyna — Mon, 25 May 2026 12:16:37 +0000

Originally published at kalyna.pro

The AI coding tool landscape exploded in 2025 and has stabilised in 2026 around a handful of genuinely useful products. As a developer who has used all of them on real projects, I'll give you an honest breakdown — what each tool actually does well, where it falls short, and which one you should reach for first depending on your stack, budget, and workflow.

Cursor

Cursor is an AI-native IDE forked from VS Code. It feels immediately familiar — all your VS Code extensions and keybindings work — but every surface has been rebuilt around AI. The two headline features are Tab autocomplete (multi-line, context-aware, faster than Copilot) and Composer, an agentic mode that can edit multiple files at once based on a single natural language instruction.

Cursor's strengths:

Composer agent — multi-file edits from a single prompt, with diff review before applying
Tab autocomplete — predicts entire blocks, not just the next token, with very low latency
Codebase indexing — embeds your repo locally so context is pulled automatically from relevant files
VS Code compatibility — drop-in replacement, zero migration cost for existing workflows
Model choice — supports Claude, GPT-4o, and Gemini; you pick per session

Pricing: Free tier (500 completions/month), Pro at $20/month. Best for: Full-stack developers who want an AI-native IDE with agentic editing.

Claude Code

Claude Code is Anthropic's CLI-based coding agent. Unlike IDE extensions that work file by file, Claude Code operates on your entire repository from the terminal. You give it a task in natural language and it reads the relevant files, writes the changes, runs commands, and reports back.

Claude Code's strengths:

Whole-repo context — reads and modifies files across the entire codebase, not just the open file
Agentic execution — runs shell commands, installs packages, and iterates based on test output
Large refactors — handles migrations, renaming, and architectural changes that touch many files
Terminal-native — integrates naturally with git, CI scripts, and developer toolchains
Transparent — shows every read, write, and command; you control what it is allowed to do

Pricing: Billed per token through the Claude API (~$20–60/month for daily use).

Best for: Large refactors, legacy codebase migrations, automated test generation. See the Claude API Python Tutorial to build your own Claude-powered tools.

GitHub Copilot

GitHub Copilot is the market leader — the tool that normalised AI assistance in everyday coding. Backed by Microsoft and OpenAI, it is embedded directly in VS Code, JetBrains IDEs, Neovim, and GitHub's web editor.

GitHub Copilot's strengths:

Ubiquity — available in VS Code, JetBrains, Neovim, and GitHub web — no workflow change required
GitHub integration — PR reviews, code explanations, and issue summarisation built into GitHub's UI
Enterprise features — org-level policy controls, code referencing filters, audit logs, and SSO
Copilot Chat — in-editor Q&A, explain-this-code, fix-this-error, write-tests-for-this shortcuts
Agent mode — multi-file scaffolding and terminal command execution

Pricing: $10/month Individual, $19/user/month Business. Best for: Developers who want reliable AI assistance without changing their IDE.

Codeium / Windsurf

Codeium (rebranded as Windsurf IDE for its flagship product) is the strongest free alternative in the market. The free tier is genuinely unlimited — no monthly completion cap — and covers autocomplete across 70+ languages.

Codeium / Windsurf strengths:

Generous free tier — unlimited autocomplete with no monthly cap, forever
Windsurf IDE — AI-native VS Code fork with Cascade agent mode included in free plan
Broad IDE support — VS Code, JetBrains, Vim/Neovim, Emacs, and more
Fast completions — low-latency inline suggestions, competitive with Copilot
Context awareness — indexes your local repo for better suggestions without a paid plan

Pricing: Free tier (unlimited completions), Pro at $15/month. Best for: Developers on a budget, students, or anyone evaluating AI coding assistance before committing to a paid tool.

v0 by Vercel

v0 is a specialised tool: you describe a UI component or page in natural language, and v0 generates working React + Tailwind CSS code you can copy directly into your project. It understands shadcn/ui components, Radix primitives, and Next.js conventions natively.

v0's strengths:

UI generation — produces complete, functional React + Tailwind components, not just HTML sketches
Component ecosystem — native knowledge of shadcn/ui, Radix UI, and Lucide icons
Iterative refinement — conversation-style editing keeps previous context and applies incremental changes
Live preview — see the rendered component alongside the code in the browser
One-click deploy — generated apps can be deployed to Vercel instantly for sharing

Pricing: Free tier (limited generations/month), Premium at $20/month. Best for: Frontend developers building React applications who want to scaffold components and pages quickly.

Amazon Q Developer

Amazon Q Developer (formerly CodeWhisperer) is Amazon's AI coding assistant, and it is the obvious choice for teams building on AWS. The free tier is generous — unlimited code completions — and the tool has been trained specifically on AWS service documentation, SDK patterns, and infrastructure-as-code.

Amazon Q Developer's strengths:

AWS expertise — trained on AWS docs, SDKs, and best practices across all major services
Free tier — unlimited code completions for individuals at no cost
Security scanning — automated vulnerability detection integrated into the IDE
IaC support — CloudFormation, CDK, and Terraform suggestions with service-specific accuracy
Agent features — multi-file code generation, unit test generation, and code explanation

Pricing: Free tier (unlimited completions, 50 agent invocations/month), Pro at $19/user/month. Best for: AWS engineers, backend developers building serverless applications.

How to Choose

Use this checklist:

Unlimited free budget? → Codeium / Windsurf — the most capable free tool
Want the best agentic IDE experience? → Cursor Pro at $20/month
Already in VS Code and want zero friction? → GitHub Copilot at $10/month
Building on AWS? → Amazon Q Developer free tier
Frontend / React-heavy work? → v0 by Vercel for UI + Cursor for logic
Large refactors or whole-repo tasks? → Claude Code CLI agent
Enterprise with audit and policy requirements? → GitHub Copilot Business or Amazon Q Pro

Quick comparison:

Tool	Best For	Price
Cursor	AI-native IDE, full-stack	$20/mo Pro
Claude Code	Whole-repo tasks, refactors	~$20–60/mo
GitHub Copilot	Ecosystem integration	$10/mo
Codeium / Windsurf	Best free tier	Free / $15/mo
v0 by Vercel	React UI generation	Free / $20/mo
Amazon Q Developer	AWS development	Free / $19/mo

Summary

Cursor is the top choice for developers who want an AI-native IDE with the most capable agentic editing available in 2026
Claude Code is unmatched for large-scale refactors and tasks that require understanding an entire repository
GitHub Copilot remains the safest default for teams that want reliable, enterprise-ready AI assistance without changing their IDE
Codeium / Windsurf gives you the most for free — a serious tool, not a trial
v0 by Vercel is a must-have for React developers; use it for UI generation, then switch to a general tool for logic
Amazon Q Developer is the clear winner for AWS-focused teams, especially given the free tier
Most experienced developers end up using two tools: one IDE assistant (Cursor or Copilot) and one task-level agent (Claude Code) for bigger jobs

Further reading:

LangChain vs LlamaIndex: Which Python AI Framework to Choose (2026)

Serhii Kalyna — Tue, 19 May 2026 05:31:29 +0000

Choosing between LangChain and LlamaIndex is one of the first decisions you face when building a Python AI application in 2026. Both frameworks accelerate LLM development, both are open source, and both have active communities — but they solve different problems.

Originally published at kalyna.pro

What Is LangChain?

LangChain is a framework for building applications powered by language models. Its core idea is composability: you chain together prompts, models, tools, memory, and agents using a unified interface called LCEL (LangChain Expression Language).

LangChain's core strengths:

Agents and tool use — first-class support for giving LLMs access to tools (web search, calculators, APIs)
Memory — conversation history, entity memory, and summary memory built in
Broad integrations — 100+ LLM providers, 50+ vector stores, dozens of data tools
LangSmith — first-party tracing, evaluation, and dataset management platform
LCEL — composable, streaming-native, async-first pipeline syntax

What Is LlamaIndex?

LlamaIndex (formerly GPT Index) is a data framework for LLM applications. Its core idea is data ingestion and indexing: you load documents from any source, index them efficiently, and query the index with natural language.

LlamaIndex's core strengths:

Document ingestion — loaders for PDFs, Word docs, databases, APIs, cloud storage, and SaaS tools
Advanced retrieval — hybrid search, re-ranking, recursive retrieval, query decomposition
Index types — vector, keyword, tree, summary, and knowledge graph indexes in one API
Query engines — natural language interfaces over structured and unstructured data
Agents — ReAct and OpenAI-style agents that reason over indexes and call tools

LangChain vs LlamaIndex: Key Differences

	LangChain	LlamaIndex
Primary focus	LLM orchestration & agents	Data indexing & RAG
Core abstraction	Chain / Runnable	Index / QueryEngine
Best for	Multi-step agents, tool use, memory	RAG over private docs, structured Q&A
Learning curve	Steeper (many abstractions)	Gentler for RAG, opinionated defaults
Ecosystem	Broader (agents, tools, evaluation)	Deeper on retrieval and indexing

When to Use LangChain

Choose LangChain when you need multi-step pipelines, agents, or conversation memory.

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatAnthropic(model="claude-sonnet-4-6")

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a concise technical writer."),
    ("human", "{question}"),
])

chain = prompt | llm | StrOutputParser()

answer = chain.invoke({"question": "What is LCEL in LangChain?"})
print(answer)

Adding Retrieval to a LangChain Chain

from langchain_anthropic import ChatAnthropic
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

llm = ChatAnthropic(model="claude-sonnet-4-6")
prompt = ChatPromptTemplate.from_template(
    "Answer using only the context below.\n\nContext:\n{context}\n\nQuestion: {question}"
)

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

print(rag_chain.invoke("What topics are covered?"))

When to Use LlamaIndex

Choose LlamaIndex when you need to ingest large document collections or apply advanced retrieval.

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Load all documents from a folder (PDF, TXT, DOCX, HTML, ...)
documents = SimpleDirectoryReader("./docs").load_data()

# Build a vector index — chunking, embedding, and storage handled automatically
index = VectorStoreIndex.from_documents(documents)

# Query with natural language
query_engine = index.as_query_engine()
response = query_engine.query("What are the main topics in these documents?")
print(response)

Using LlamaIndex with Claude

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.anthropic import Anthropic
from llama_index.embeddings.huggingface import HuggingFaceEmbedding

Settings.llm = Anthropic(model="claude-sonnet-4-6")
Settings.embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")

documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine(similarity_top_k=5)
response = query_engine.query("Summarize the key findings.")
print(response)

Can You Use Both Together?

Yes — use LlamaIndex for retrieval and LangChain for orchestration:

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# LlamaIndex: build the index and retrieve context
documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents)
retriever = index.as_retriever(similarity_top_k=4)


def retrieve_context(question: str) -> str:
    nodes = retriever.retrieve(question)
    return "\n\n".join(n.get_content() for n in nodes)


# LangChain: format and generate the answer
llm = ChatAnthropic(model="claude-sonnet-4-6")
prompt = ChatPromptTemplate.from_template(
    "Answer using only the context.\n\nContext:\n{context}\n\nQuestion: {question}"
)
chain = prompt | llm | StrOutputParser()

question = "What deployment options are available?"
context = retrieve_context(question)
answer = chain.invoke({"context": context, "question": question})
print(answer)

This separation lets you upgrade each layer independently.

Performance and Ecosystem

Streaming — both stream tokens natively; LangChain's LCEL is explicitly streaming-first
Async — LangChain: chain.ainvoke(); LlamaIndex: query_engine.aquery()
Batching — LangChain's chain.batch() parallelises multiple inputs automatically
Community — LangChain ~90k GitHub stars; LlamaIndex ~37k stars, more enterprise-focused
API stability — both stabilised after major rewrites and are production-ready in 2026
Shared ecosystem — both integrate with Chroma, Pinecone, Weaviate, Qdrant, pgvector, and every major LLM provider

In RAG accuracy benchmarks, LlamaIndex's default retrieval pipeline consistently matches or beats LangChain's equivalent with less configuration.

Choosing the Right Tool

Need agents that call tools dynamically? → LangChain
Building a RAG pipeline over a large document collection? → LlamaIndex
Need advanced retrieval: hybrid search, re-ranking, recursive? → LlamaIndex
Need conversation memory or multi-turn dialogue? → LangChain
Q&A over SQL, CSV, or Pandas DataFrames? → LlamaIndex
Orchestrating multiple LLM calls with conditional branching? → LangChain
Want minimal boilerplate for a quick RAG prototype? → LlamaIndex
Production system needing both rich retrieval and agent behaviour? → Both

Summary

LangChain excels at orchestration — chaining LLM steps, building agents, managing memory
LlamaIndex excels at data — ingesting documents, building indexes, and powering RAG pipelines
Both support async, streaming, and the same popular vector stores and LLM providers
They are complementary — many production systems use LlamaIndex for retrieval inside a LangChain agent
For most RAG use cases in 2026, start with LlamaIndex; for multi-step agent workflows, start with LangChain

Further reading:

Cursor AI Editor Review: Is It Worth the Upgrade? (2026)

Serhii Kalyna — Mon, 18 May 2026 13:13:22 +0000

Cursor AI Editor Review: Is It Worth the Upgrade? (2026)

If you spend most of your day writing code, Cursor AI will change how you work. It's not another VS Code extension — it's a full editor built from a VS Code fork, with AI woven into every layer.

What Is Cursor AI?

Cursor is a code editor by Anysphere. VS Code fork with AI as a first-class citizen — not a plugin.

Key Features

Cursor Tab — multi-line, context-aware completion
Chat (Ctrl+L) — ask anything about your codebase, use @file references
Inline Edit (Ctrl+K) — select code, describe change, see diff preview
Agent Mode (Ctrl+I) — create/edit multiple files, run terminal commands
.cursorrules — project-level AI instructions

Cursor vs VS Code + GitHub Copilot

Feature	Cursor Pro	VS Code + Copilot
Codebase context	✅ Full project	⚠️ Open files only
Multi-file editing	✅ Agent mode	❌ Single file
Inline diff preview	✅ Before accepting	❌ Apply then undo
Price	$20/month	$10/month

Pricing

Free — 2,000 completions/month, 50 slow premium requests
Pro ($20/month) — unlimited completions, 500 fast premium requests
Business ($40/user/month) — SSO, audit logs, zero data retention

Verdict

For most developers: yes. Codebase context + Agent mode together save multiple hours per week on real projects. The $10 premium over Copilot pays for itself in the first complex refactoring session.

Originally published at kalyna.pro

Multi-Agent Systems with LLMs: A Developer's Guide (2026)

Serhii Kalyna — Fri, 15 May 2026 12:53:34 +0000

A multi-agent system is a group of AI agents that each handle a specific task and pass results to one another. Instead of prompting one model to do everything, you split the work — a researcher finds facts, a writer drafts content, an editor reviews it.

Originally published at kalyna.pro

Why Multi-Agent?

Single-agent LLM calls hit limits quickly:

Context window overflow — one agent can't hold a 200-page report and write a summary simultaneously
Quality degradation — researching AND writing AND fact-checking in one prompt produces mediocre results
No parallelism — agents can run simultaneously; sequential prompts cannot
Hard to debug — when one big prompt fails, you don't know which step broke

Core Architecture Patterns

1. Orchestrator → Workers

Orchestrator
├── Research Agent    → gathers data
├── Analysis Agent    → interprets data
└── Writer Agent      → produces output

2. Pipeline (Sequential)

Input → Researcher → Drafter → Editor → Output

3. Parallel Fan-Out

         ┌─ Agent A ─┐
Input ───┤─ Agent B ─├─── Merger ── Output
         └─ Agent C ─┘

Simple Two-Agent Pipeline

import anthropic

client = anthropic.Anthropic()


def researcher(topic: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="You are a technical researcher. Return 5-7 concise bullet points.",
        messages=[{"role": "user", "content": f"Research topic: {topic}"}],
    )
    return response.content[0].text


def writer(topic: str, research: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2048,
        system="You are a technical writer for developers. Write clear, practical prose.",
        messages=[{
            "role": "user",
            "content": f"Topic: {topic}\n\nResearch:\n{research}\n\nWrite a 3-paragraph explanation.",
        }],
    )
    return response.content[0].text


topic = "how transformer attention mechanisms work"
facts = researcher(topic)
article = writer(topic, facts)
print(article)

Orchestrator Pattern

import anthropic
from dataclasses import dataclass

@dataclass
class AgentResult:
    agent: str
    output: str

client = anthropic.Anthropic()


def run_agent(name: str, system: str, user: str, max_tokens: int = 1024) -> AgentResult:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=max_tokens,
        system=system,
        messages=[{"role": "user", "content": user}],
    )
    return AgentResult(agent=name, output=response.content[0].text)


def orchestrator(task: str) -> str:
    research = run_agent("Researcher", "Return bullet-point facts only.", f"Research: {task}")
    draft = run_agent(
        "Writer", "Write clearly for developers.",
        f"Task: {task}\n\nResearch:\n{research.output}\n\nWrite a draft.",
        max_tokens=2048,
    )
    final = run_agent(
        "Editor", "Fix clarity, remove redundancy. Return only the improved text.",
        f"Edit:\n\n{draft.output}",
        max_tokens=2048,
    )
    return final.output

Parallel Fan-Out

from concurrent.futures import ThreadPoolExecutor, as_completed

def research_source(source_name: str, topic: str) -> tuple[str, str]:
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=512,
        messages=[{"role": "user", "content": f"You are a {source_name} expert. Give 3 bullet points about: {topic}"}],
    )
    return source_name, response.content[0].text


def parallel_research(topic: str, sources: list[str]) -> dict[str, str]:
    results = {}
    with ThreadPoolExecutor(max_workers=len(sources)) as pool:
        futures = {pool.submit(research_source, s, topic): s for s in sources}
        for future in as_completed(futures):
            name, output = future.result()
            results[name] = output
    return results


research = parallel_research("LLMs in production", ["DevOps", "ML Engineering", "Security"])

Agent Handoffs with State

from dataclasses import dataclass, field

@dataclass
class PipelineState:
    topic: str
    research: str = ""
    outline: str = ""
    draft: str = ""
    errors: list[str] = field(default_factory=list)


def research_agent(state: PipelineState) -> PipelineState:
    try:
        resp = client.messages.create(
            model="claude-haiku-4-5", max_tokens=512,
            messages=[{"role": "user", "content": f"Research: {state.topic}"}],
        )
        state.research = resp.content[0].text
    except Exception as e:
        state.errors.append(f"research: {e}")
    return state

When to Use Multi-Agent vs Single Agent

Scenario	Approach
Task fits in one prompt	Single agent
Clear sequential steps	Pipeline
Complex, dynamic steps	Orchestrator
Independent sub-tasks	Parallel fan-out

Cost Tips

Use claude-haiku-4-5 for worker agents, claude-sonnet-4-6 for synthesis
Parallelize independent agents to cut wall-clock time
Enable prompt caching for shared system prompts
Cap per-agent max_tokens — researchers don't need 4096

Summary

Multi-agent systems let you build AI pipelines that are smarter, faster, and easier to debug:

Split work by skill: researcher, writer, editor
Run independent agents in parallel with ThreadPoolExecutor
Pass structured state between agents
Use cheap models for workers, powerful models for synthesis
Fail fast and log errors per agent

ChromaDB Tutorial: Build Your First Vector Database with Python (2026)

Serhii Kalyna — Fri, 15 May 2026 12:49:45 +0000

ChromaDB is an open-source vector database designed for AI applications. It stores embeddings locally, runs without a server, and integrates with any Python project in minutes.

Originally published at kalyna.pro

What Is ChromaDB?

A vector database stores data as high-dimensional vectors (embeddings) and lets you search by semantic similarity — not exact keyword match.

ChromaDB stands out because:

No server needed — runs in-process or as a local server
Persistent storage — data survives restarts
Built-in embeddings — uses sentence-transformers out of the box
Simple API — add, query, update, delete in a few lines

Installation

pip install chromadb
pip install sentence-transformers  # for default embeddings

Your First Collection

import chromadb

client = chromadb.Client()
collection = client.create_collection("my_docs")

collection.add(
    documents=[
        "Python is a high-level programming language.",
        "ChromaDB is an open-source vector database.",
        "Machine learning models require large datasets.",
        "Docker containers package apps with their dependencies.",
        "Claude is an AI assistant built by Anthropic.",
    ],
    ids=["doc1", "doc2", "doc3", "doc4", "doc5"],
)

results = collection.query(
    query_texts=["What is a vector database?"],
    n_results=2,
)

for doc, dist in zip(results["documents"][0], results["distances"][0]):
    print(f"[{dist:.3f}] {doc}")

Output:

[0.312] ChromaDB is an open-source vector database.
[0.578] Python is a high-level programming language.

Persistent Storage

client = chromadb.PersistentClient(path="./chroma_db")

collection = client.get_or_create_collection("my_docs")
collection.add(
    documents=["This data will survive a restart."],
    ids=["persistent_doc1"],
)

Embeddings: Default vs Custom

Sentence Transformers (local, free)

from chromadb.utils import embedding_functions

embed_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)
collection = client.get_or_create_collection("docs", embedding_function=embed_fn)

OpenAI Embeddings

embed_fn = embedding_functions.OpenAIEmbeddingFunction(
    api_key="sk-...",
    model_name="text-embedding-3-small",
)

Use the same embedding function every time you open the same collection.

Metadata and Filtering

collection.add(
    documents=[
        "GPT-4 is a large language model by OpenAI.",
        "Claude Sonnet is fast and affordable.",
        "Llama 3 is an open-source model by Meta.",
    ],
    ids=["gpt4", "claude", "llama3"],
    metadatas=[
        {"company": "OpenAI",    "open_source": False},
        {"company": "Anthropic", "open_source": False},
        {"company": "Meta",      "open_source": True},
    ],
)

# Only open-source models
results = collection.query(
    query_texts=["free models"],
    n_results=2,
    where={"open_source": True},
)

Filter Operators

where={"company": "Anthropic"}                              # exact match
where={"company": {"$ne": "OpenAI"}}                        # not equal
where={"company": {"$in": ["Anthropic", "Meta"]}}           # in list
where={"$and": [{"open_source": True}, {"company": {"$ne": "Meta"}}]}  # combine

Getting, Updating, and Deleting

# Get by ID
result = collection.get(ids=["doc1", "doc2"])

# Update
collection.update(
    ids=["doc1"],
    documents=["Updated text goes here."],
    metadatas=[{"updated": True}],
)

# Delete by ID or filter
collection.delete(ids=["doc4"])
collection.delete(where={"company": "OpenAI"})

print(f"Documents: {collection.count()}")

Integration with Claude

import anthropic
import chromadb
from chromadb.utils import embedding_functions

client = chromadb.PersistentClient(path="./chroma_db")
embed_fn = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
col = client.get_collection("knowledge_base", embedding_function=embed_fn)
claude = anthropic.Anthropic()


def answer(question: str, n_results: int = 4) -> str:
    chunks = col.query(query_texts=[question], n_results=n_results)["documents"][0]
    context = "\n\n".join(chunks)

    response = claude.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="Answer using ONLY the context. If not found, say so.",
        messages=[{"role": "user", "content": f"Context:\n{context}\n\nQuestion: {question}"}],
    )
    return response.content[0].text

Running ChromaDB as a Server

chroma run --path ./chroma_db --port 8000

import chromadb
client = chromadb.HttpClient(host="localhost", port=8000)

Summary

ChromaDB gives you a full vector database in a single pip install:

Create collections, add documents, query by semantic similarity
Persist data to disk with PersistentClient
Filter results with metadata using where
Plug in any embedding model — local or API-based
Combine with Claude to build RAG applications

Next: RAG Tutorial with Python or Build a RAG Chatbot.

How to Build a RAG Chatbot with Python

Serhii Kalyna — Wed, 13 May 2026 06:16:12 +0000

A RAG (Retrieval-Augmented Generation) chatbot answers questions based on your own documents — not just its training data. This guide builds one from scratch using Python, ChromaDB, and Claude.

Originally published at kalyna.pro

What Is RAG?

RAG combines two things:

Retrieval: search your documents for relevant chunks
Generation: use an LLM to write an answer based on those chunks

Without RAG, Claude can only answer questions based on its training data. With RAG, you inject relevant context directly into the prompt.

Architecture

Indexing: load docs → split into chunks → embed → store in vector DB
Querying: embed question → find similar chunks → send to Claude → return answer

Step 1: Install Dependencies

pip install anthropic chromadb sentence-transformers pypdf2

Step 2: Load and Chunk Documents

import PyPDF2
from pathlib import Path


def load_pdf(path: str) -> str:
    with open(path, "rb") as f:
        reader = PyPDF2.PdfReader(f)
        return "\n".join(page.extract_text() for page in reader.pages)


def chunk_text(text: str, chunk_size: int = 500, overlap: int = 50) -> list[str]:
    words = text.split()
    chunks = []
    i = 0
    while i < len(words):
        chunks.append(" ".join(words[i : i + chunk_size]))
        i += chunk_size - overlap
    return chunks

Step 3: Build the Vector Index

import chromadb
from chromadb.utils import embedding_functions

embed_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)
client = chromadb.PersistentClient(path="./chroma_db")


def build_index(documents: list[dict], collection_name: str = "docs"):
    collection = client.get_or_create_collection(
        name=collection_name,
        embedding_function=embed_fn,
    )
    texts, ids, metadatas = [], [], []
    for i, doc in enumerate(documents):
        for j, chunk in enumerate(chunk_text(doc["text"])):
            texts.append(chunk)
            ids.append(f"{doc['source']}_chunk_{j}")
            metadatas.append({"source": doc["source"]})

    collection.add(documents=texts, ids=ids, metadatas=metadatas)
    return collection

Step 4: Query + Generate Answer

def retrieve(question: str, collection, n_results: int = 5) -> list[str]:
    return collection.query(query_texts=[question], n_results=n_results)["documents"][0]


def generate_answer(question: str, chunks: list[str]) -> str:
    context = "\n\n---\n\n".join(chunks)
    response = claude.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"Answer using ONLY the context below.\n\nContext:\n{context}\n\nQuestion: {question}"
        }],
    )
    return response.content[0].text

Step 5: Full Chatbot Script

import anthropic
import chromadb
from chromadb.utils import embedding_functions
import PyPDF2
from pathlib import Path

embed_fn = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
chroma = chromadb.PersistentClient(path="./chroma_db")
claude = anthropic.Anthropic()


def index_files(file_paths: list[str]) -> None:
    collection = chroma.get_or_create_collection("docs", embedding_function=embed_fn)
    texts, ids, metas = [], [], []
    for path in file_paths:
        p = Path(path)
        if p.suffix == ".pdf":
            with open(p, "rb") as f:
                text = "\n".join(page.extract_text() for page in PyPDF2.PdfReader(f).pages)
        else:
            text = p.read_text()
        for j, chunk in enumerate(chunk_text(text)):
            texts.append(chunk); ids.append(f"{p.name}_{j}"); metas.append({"source": path})
    collection.add(documents=texts, ids=ids, metadatas=metas)
    print(f"Indexed {len(texts)} chunks")


def ask(question: str) -> str:
    collection = chroma.get_collection("docs", embedding_function=embed_fn)
    chunks = collection.query(query_texts=[question], n_results=5)["documents"][0]
    context = "\n\n---\n\n".join(chunks)
    response = claude.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": f"Context:\n{context}\n\nQuestion: {question}"}],
    )
    return response.content[0].text


if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1:
        index_files(sys.argv[1:])
    else:
        print("RAG Chatbot ready. Type 'quit' to exit.")
        while True:
            q = input("You: ").strip()
            if q.lower() in ("quit", "exit"): break
            print("Bot:", ask(q), "\n")

Usage

# Index documents
python chatbot.py company_handbook.pdf product_docs.txt

# Start chatting
python chatbot.py

Performance Tips

Chunk size: 300–600 words is a good starting range
Increase n_results for complex questions
Metadata filtering: where={'source': 'specific.pdf'} to restrict search
Reranking: use a cross-encoder reranker for production quality
Caching: cache embeddings to speed up re-indexing

Summary

You built a RAG chatbot that:

Loads PDF and text documents
Splits into overlapping chunks
Embeds and stores in ChromaDB
Retrieves relevant chunks per question
Generates grounded answers with Claude

How to Get Your Anthropic Claude API Key

Serhii Kalyna — Wed, 13 May 2026 06:14:42 +0000

To use Claude in your applications, you need an Anthropic API key. This guide shows you exactly how to get one, how to set it up securely, and what you need to know about rate limits and billing.

This article was originally published at kalyna.pro

Step 1: Create an Anthropic Account

Go to console.anthropic.com and click Sign Up. You can register with Google or an email address. Email verification is required.

Once logged in, you land on the Anthropic Console — the dashboard where you manage keys, usage, and billing.

Step 2: Get Your API Key

In the Console, navigate to Settings → API Keys (or click your avatar → API Keys). Then:

Click Create Key
Give it a descriptive name (e.g., my-app-dev)
Click Create Key — copy it immediately
Store it somewhere safe — you won't see the full key again

Your key looks like: sk-ant-api03-...

Step 3: Add a Payment Method

API access requires a credit card on file. Go to Settings → Billing and add your card. Usage is billed monthly — you're only charged for what you use.

Step 4: Set Your API Key Securely

Never paste your API key directly into source code. Use environment variables:

# Linux / macOS — add to ~/.bashrc or ~/.zshrc
export ANTHROPIC_API_KEY="sk-ant-api03-..."

# Windows PowerShell
$env:ANTHROPIC_API_KEY = "sk-ant-api03-..."

For projects, use a .env file (and add it to .gitignore):

# .env
ANTHROPIC_API_KEY=sk-ant-api03-...

# .gitignore
.env
*.env

Step 5: Test Your Key

Python:

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY automatically

message = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=64,
    messages=[{"role": "user", "content": "Say hello!"}],
)
print(message.content[0].text)

Node.js:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-haiku-4-5",
  max_tokens: 64,
  messages: [{ role: "user", content: "Say hello!" }],
});

console.log(message.content[0].text);

curl:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-haiku-4-5",
    "max_tokens": 64,
    "messages": [{"role": "user", "content": "Say hello!"}]
  }'

Understanding Rate Limits

Tier	RPM	TPM	TPD
Tier 1 ($5+ spent)	50	40,000	1,000,000
Tier 2 ($100+/30d)	1,000	80,000	2,500,000
Tier 3 ($500+/30d)	2,000	160,000	—

When rate-limited (HTTP 429), use exponential backoff:

import time
import anthropic

client = anthropic.Anthropic()

def call_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model="claude-haiku-4-5",
                max_tokens=512,
                messages=[{"role": "user", "content": prompt}],
            )
        except anthropic.RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt
            print(f"Rate limited. Waiting {wait}s...")
            time.sleep(wait)

Multiple Keys Best Practices

Create separate keys per environment:

Development my-app-dev — local testing
Staging my-app-staging — pre-production
Production my-app-prod — live traffic
CI/CD my-app-ci — automated tests

Revoke a compromised key without affecting others: API Keys → three dots → Delete.

Pricing Overview

Model	Input (per 1M tokens)	Output (per 1M tokens)
claude-haiku-4-5	$0.80	$4.00
claude-sonnet-4-5	$3.00	$15.00
claude-opus-4-5	$15.00	$75.00

Summary

Sign up at console.anthropic.com and create a key under Settings → API Keys
Store the key in an environment variable, never in code
Add a payment method — billing is pay-as-you-go
Test with claude-haiku-4-5 before switching to Sonnet or Opus
Create separate keys per environment; revoke immediately if leaked
Monitor spending via the Console and set billing alerts

Vector Databases Comparison: Pinecone vs Chroma vs Weaviate (2026)

Serhii Kalyna — Fri, 08 May 2026 10:22:04 +0000

Choosing a vector database is one of the first decisions in any RAG project. Three options dominate developer usage: Pinecone, Chroma, and Weaviate. Here's a practical comparison.

Quick Overview

	Pinecone	Chroma	Weaviate
Hosting	Managed cloud only	Local or cloud	Self-hosted or cloud
Setup time	5 minutes	1 minute	10–20 minutes
Free tier	Yes (1 index)	Yes (local)	Yes (self-hosted)
Best for	Production scale	Development, prototyping	Hybrid search, complex queries

Chroma: Start Here

Chroma runs in-process — no server needed. Perfect for development and small projects.

pip install chromadb

import chromadb
from chromadb.utils import embedding_functions

client = chromadb.PersistentClient("./chroma_db")

ef = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"
)

collection = client.get_or_create_collection("docs", embedding_function=ef)

collection.add(
    documents=[
        "RAG stands for Retrieval-Augmented Generation.",
        "Fine-tuning updates model weights on new data.",
        "Vector search finds semantically similar content.",
    ],
    ids=["doc1", "doc2", "doc3"],
)

results = collection.query(query_texts=["how does RAG work?"], n_results=2)
print(results["documents"])

Pros: Zero setup, runs locally, great for prototyping.
Cons: Not designed for multi-node scale, no built-in auth.

Pinecone: Managed Scale

Pinecone is a fully managed vector database. No infrastructure to run.

pip install pinecone-client sentence-transformers

from pinecone import Pinecone, ServerlessSpec
from sentence_transformers import SentenceTransformer

pc = Pinecone(api_key="YOUR_PINECONE_API_KEY")

pc.create_index(
    name="kalyna-docs",
    dimension=384,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1"),
)

index = pc.Index("kalyna-docs")
model = SentenceTransformer("all-MiniLM-L6-v2")

texts = ["RAG is a retrieval technique.", "Fine-tuning changes model weights."]
embeddings = model.encode(texts).tolist()

index.upsert(vectors=[
    {"id": "v1", "values": embeddings[0], "metadata": {"text": texts[0]}},
    {"id": "v2", "values": embeddings[1], "metadata": {"text": texts[1]}},
])

query_vec = model.encode(["how to retrieve documents?"]).tolist()[0]
results = index.query(vector=query_vec, top_k=2, include_metadata=True)
for match in results.matches:
    print(match.metadata["text"], "| score:", round(match.score, 3))

Pros: Zero ops, scales automatically, fast at large scale.
Cons: Vendor lock-in, can get expensive, free tier limits.

Weaviate: Hybrid Search

Weaviate supports both vector search and keyword (BM25) search — called hybrid search.

pip install weaviate-client
docker run -p 8080:8080 cr.weaviate.io/semitechnologies/weaviate:latest

import weaviate
from weaviate.classes.config import Configure, Property, DataType

client = weaviate.connect_to_local()

client.collections.create(
    "Document",
    vectorizer_config=Configure.Vectorizer.text2vec_transformers(),
    properties=[
        Property(name="content", data_type=DataType.TEXT),
        Property(name="source", data_type=DataType.TEXT),
    ],
)

collection = client.collections.get("Document")
collection.data.insert({"content": "RAG retrieves documents at inference time.", "source": "guide"})

results = collection.query.hybrid(
    query="retrieval augmented generation",
    alpha=0.5,  # 0 = pure keyword, 1 = pure vector
    limit=2,
)
for obj in results.objects:
    print(obj.properties["content"])

client.close()

Pros: Hybrid search, strong filtering, active community.
Cons: More complex setup, steeper learning curve.

Which One to Pick?

Chroma — prototyping, demos, local development. Working in 10 minutes.

Pinecone — production, you don't want to manage infrastructure. Pay for convenience.

Weaviate — hybrid search (semantic + keyword), complex filters, multi-tenant systems.

With Claude (RAG Example)

import anthropic

def rag_answer(question: str) -> str:
    results = collection.query(query_texts=[question], n_results=3)
    context = "\n".join(results["documents"][0])

    client = anthropic.Anthropic()
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,
        messages=[{
            "role": "user",
            "content": f"Answer based on this context only:\n{context}\n\nQuestion: {question}"
        }]
    )
    return response.content[0].text

This pattern works identically with Pinecone or Weaviate — just swap the retrieval step.

Originally published at kalyna.pro

Building a Telegram Bot with Claude API (Python, 2026)

Serhii Kalyna — Fri, 08 May 2026 10:16:43 +0000

A Telegram bot powered by Claude gives you a personal AI assistant accessible from your phone. In this tutorial you'll build one from scratch — handling messages, keeping conversation history, and deploying it.

Prerequisites

Python 3.10+
Anthropic API key
Telegram account

Step 1: Create a Telegram Bot

Open Telegram, search for @botfather
Send /newbot and follow the prompts
Copy the bot token (looks like 7123456789:AAF...)

Step 2: Install Dependencies

pip install python-telegram-bot anthropic

Step 3: Basic Echo Bot

from telegram import Update
from telegram.ext import Application, MessageHandler, filters, ContextTypes

BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = update.message.text
    await update.message.reply_text(f"You said: {text}")

app = Application.builder().token(BOT_TOKEN).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
app.run_polling()

Test it first — make sure messages echo back before adding Claude.

Step 4: Add Claude

from telegram import Update
from telegram.ext import Application, MessageHandler, CommandHandler, filters, ContextTypes
import anthropic

BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
claude = anthropic.Anthropic()

conversations: dict[int, list] = {}

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    chat_id = update.effective_chat.id
    user_text = update.message.text

    if chat_id not in conversations:
        conversations[chat_id] = []
    conversations[chat_id].append({"role": "user", "content": user_text})

    history = conversations[chat_id][-20:]

    response = claude.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="You are a helpful assistant. Be concise — this is a Telegram chat.",
        messages=history,
    )

    reply = response.content[0].text
    conversations[chat_id].append({"role": "assistant", "content": reply})
    await update.message.reply_text(reply)


async def reset_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    conversations.pop(update.effective_chat.id, None)
    await update.message.reply_text("Conversation reset.")


app = Application.builder().token(BOT_TOKEN).build()
app.add_handler(CommandHandler("reset", reset_command))
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
app.run_polling()

Step 5: Add Typing Indicator

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_chat_action(chat_id=update.effective_chat.id, action="typing")
    # ... rest of handler

Step 6: Handle Long Responses

Telegram has a 4096-character limit. Split long responses:

def split_message(text: str, limit: int = 4000) -> list[str]:
    if len(text) <= limit:
        return [text]
    parts = []
    while text:
        parts.append(text[:limit])
        text = text[limit:]
    return parts

# In your handler:
for part in split_message(reply):
    await update.message.reply_text(part)

Step 7: Deploy on a VPS

# /etc/systemd/system/claude-bot.service
[Unit]
Description=Claude Telegram Bot
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/home/ubuntu/claude-bot
ExecStart=/usr/bin/python3 bot.py
Restart=always
Environment=ANTHROPIC_API_KEY=your-key
Environment=BOT_TOKEN=your-token

[Install]
WantedBy=multi-user.target

sudo systemctl enable claude-bot
sudo systemctl start claude-bot

Cost Estimate

With 100 daily messages (avg 200 input + 150 output tokens each) on Sonnet:

Input: ~$0.06/day
Output: ~$0.23/day
Total: ~$9/month

Add prompt caching on the system prompt to cut input costs by ~90%.

What to Build Next

/summarize command — paste a URL, get a summary
Image analysis — handle filters.PHOTO and use Claude's vision
Scheduled reminders — use job_queue from python-telegram-bot
Group chat mode — different system prompt for group vs private

Originally published at kalyna.pro