TimesFM (Time Series Foundation Model) je open-source model pro předpověď časových řad, který vyvíjí Google Research. Za projektem stojí tým z Google Research a Google Cloud — mezi klíčová jména patří Rajat Sen a Yichen Zhou. Práce byla přijata na konferenci ICML 2024. Model je dostupný na GitHubu a HuggingFace, a od verze 1.0 je integrovaný i jako oficiální produkt přímo v Google BigQuery.

TimesFM řeší jeden z klasických problémů prediktivní analytiky: tradiční modely pro předpověď časových řad vyžadují dlouhé tréninkové cykly na konkrétních datech, než je lze nasadit. TimesFM funguje jako foundation model — podobně jako LLM, který zvládne nový úkol bez fine-tuningu. Stačí mu dodat historická data a rovnou vrátí předpověď. To se hodí všude tam, kde se pracuje s daty v čase: predikce poptávky v retailu, finanční forecasting, sledování provozu, výroba nebo healthcare. Nejnovější verze 2.5 navíc podporuje kontext až 16 000 časových kroků a přidává volitelnou kvantilovou hlavu pro intervalové předpovědi.

Z čísel: TimesFM 2.5 má 200M parametrů, což je pokles z 500M v předchozí verzi 2.0. Přes tuto velikost překonává v zero-shot režimu statistické metody jako ARIMA a ETS, a na benchmarku Monash Forecasting Archive se vyrovná supervizovaným DL modelům jako DeepAR nebo PatchTST — přestože ty byly na daných datech přímo trénované. Na ETT benchmarku TimesFM překonává i GPT-3.5 použitý pro forecasting přes prompting (llmtime), a to při výrazně menší velikosti modelu. Celý model byl předtrénován na 100 miliardách reálných časových bodů, z nichž velkou část tvoří data z Google Trends a Wikipedia Pageviews.

Zdroje:

• https://github.com/google-research/timesfm
• https://research.google/blog/a-decoder-only-foundation-model-for-time-series-forecasting/
• https://arxiv.org/abs/2310.10688
• https://huggingface.co/collections/google/timesfm-release-66e4be5fdb56e960c1e482a6
• https://cloud.google.com/bigquery/docs/timesfm-model

The post AI Bits – TimesFM first appeared on Hard Wired.

Multimodal Embedding & Reranker Models with Sentence Transformers

Sentence Transformers is a Python library for using and training embedding and reranker models for applications like retrieval augmented generation, semantic search, and more. With the v5.4 update, you can now encode and compare texts, images, audio, and videos using the same familiar API. In this blogpost, I'll show you how to use these new multimodal capabilities for both embedding and reranking.

Multimodal embedding models map inputs from different modalities into a shared embedding space, while multimodal reranker models score the relevance of mixed-modality pairs. This opens up use cases like visual document retrieval, cross-modal search, and multimodal RAG pipelines.

Table of Contents

• What are Multimodal Models?
• Installation
• Multimodal Embedding Models
• Loading a Model
• Encoding Images
• Cross-Modal Similarity
• Encoding Queries and Documents
• Multimodal Reranker Models
• Ranking Mixed-Modality Documents
• Predicting Pair Scores
• Retrieve and Rerank
• Input Formats and Configuration
• Supported Input Types
• Checking Modality Support
• Processor and Model kwargs
• Supported Models
• Additional Resources

What are Multimodal Models?

Traditional embedding models convert text into fixed-size vectors. Multimodal embedding models extend this by mapping inputs from different modalities (text, images, audio, or video) into a shared embedding space. This means you can compare a text query against image documents (or vice versa) using the same similarity functions you're already familiar with.

Similarly, traditional reranker (Cross Encoder) models compute relevance scores between pairs of texts. Multimodal rerankers can score pairs where one or both elements are images, combined text-image documents, or other modalities.

For example, you can compare a text query against image documents, find video clips matching a description, or build RAG pipelines that work across modalities.

Installation

Multimodal models require some extra dependencies. Install the extras for the modalities you need (see Installation for more details):

# For image support
pip install -U "sentence-transformers[image]"

# For audio support
pip install -U "sentence-transformers"

# For video support
pip install -U "sentence-transformers"

# Mix and match as needed
pip install -U "sentence-transformers[image,video,train]"

VLM-based models like Qwen3-VL-2B require a GPU with at least ~8 GB of VRAM. For the 8B variants, expect ~20 GB. If you don't have a local GPU, consider using a cloud GPU service or Google Colab. On CPU, these models will be extremely slow; text-only or CLIP models are better suited for CPU inference.

Multimodal Embedding Models

Loading a Model

Loading a multimodal embedding model works exactly like loading a text-only model:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B", revision="refs/pr/23")

The revision argument is required for now because the integration pull requests for these models are still pending. Once they're merged, you'll be able to load them without specifying a revision.

The model automatically detects which modalities it supports, so there's nothing extra to configure. See Processor and Model kwargs if you want to control things like image resolution or model precision.

Encoding Images

With a multimodal model loaded, model.encode() accepts images alongside text. Images can be provided as URLs, local file paths, or PIL Image objects (see Supported Input Types for all accepted formats):

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B", revision="refs/pr/23")

# Encode images from URLs
img_embeddings = model.encode([
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
])
print(img_embeddings.shape)
# (2, 2048)

Cross-Modal Similarity

You can compute similarities between text embeddings and image embeddings, since the model maps both into the same space:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B", revision="refs/pr/23")

# Encode images
img_embeddings = model.encode([
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
])

# Encode text queries (one matching + one hard negative per image)
text_embeddings = model.encode([
 "A green car parked in front of a yellow building",
 "A red car driving on a highway",
 "A bee on a pink flower",
 "A wasp on a wooden table",
])

# Compute cross-modal similarities
similarities = model.similarity(text_embeddings, img_embeddings)
print(similarities)
# tensor([[0.5115, 0.1078],
# [0.1999, 0.1108],
# [0.1255, 0.6749],
# [0.1283, 0.2704]])

As expected, "A green car parked in front of a yellow building" is most similar to the car image (0.51), and "A bee on a pink flower" is most similar to the bee image (0.67). The hard negatives ("A red car driving on a highway", "A wasp on a wooden table") correctly receive lower scores.

You might notice that even the best matching scores (0.51, 0.67) aren't very close to 1.0. This is due to the modality gap: embeddings from different modalities tend to cluster in separate regions of the space. Cross-modal similarities are typically lower than within-modal ones (e.g., text-to-text), but the relative ordering is preserved, so retrieval still works well.

Encoding Queries and Documents

For retrieval tasks, encode_query() and encode_document() are the recommended methods. Many retrieval models prepend different instruction prompts depending on whether the input is a query or a document, similar to how chat models might apply different system prompts depending on the goal. Model authors can specify their prompts in the model config, and encode_query() / encode_document() automatically load and apply the correct one:

• encode_query() uses the model's "query" prompt (if available) and sets task="query".
• encode_document() uses the first available prompt from "document", "passage", or "corpus", and sets task="document".

Under the hood, both are thin wrappers around encode(), they just handle prompt selection for you. Here's what cross-modal retrieval looks like:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B", revision="refs/pr/23")

# Encode text queries with the query prompt
query_embeddings = model.encode_query([
 "Find me a photo of a vehicle parked near a building",
 "Show me an image of a pollinating insect",
])

# Encode document screenshots with the document prompt
doc_embeddings = model.encode_document([
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
])

# Compute similarities
similarities = model.similarity(query_embeddings, doc_embeddings)
print(similarities)
# tensor([[0.3907, 0.1490],
# [0.1235, 0.4872]])

These methods accept the same input types as encode() (images, URLs, multimodal dicts, etc.) and pass through the same parameters. For models without specialized query/document prompts, they behave identically to encode().

Multimodal Reranker Models

Multimodal reranker (CrossEncoder) models score the relevance between pairs of inputs, where each element can be text, an image, audio, video, or a combination. They tend to outperform embedding models in terms of quality, but are slower since they process each pair individually. The currently available pretrained multimodal rerankers focus on text and image inputs, but the architecture supports any modality that the underlying model can handle.

Ranking Mixed-Modality Documents

The rank() method scores and ranks a list of documents against a query, supporting mixed modalities:

from sentence_transformers import CrossEncoder

model = CrossEncoder("Qwen/Qwen3-VL-Reranker-2B", revision="refs/pr/11")

query = "A green car parked in front of a yellow building"
documents = [
 # Image documents (URL or local file path)
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
 # Text document
 "A vintage Volkswagen Beetle painted in bright green sits in a driveway.",
 # Combined text + image document
 {
 "text": "A car in a European city",
 "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
 },
]

rankings = model.rank(query, documents)
for rank in rankings:
 print(f"{rank['score']:.4f}\t(document {rank['corpus_id']})")
"""
0.9375 (document 0)
0.5000 (document 3)
-1.2500 (document 2)
-2.4375 (document 1)
"""

The reranker correctly identifies the car image (document 0) as the most relevant result, followed by the combined text+image document about a car in a European city (document 3). The bee image (document 1) scores lowest.

Keep in mind that the modality gap can influence absolute scores: text-image pair scores may occupy a different range than text-text or image-image pair scores.

You can also check which modalities a reranker supports using modalities and supports(), just like with embedding models:

print(model.modalities)
# ['text', 'image', 'video', 'message']

print(model.supports("image"))
# True

# Check if the model supports a specific pair of modalities
print(model.supports(("image", "text")))
# True

Predicting Pair Scores

You can also use predict() to get raw relevance scores for specific pairs of inputs:

from sentence_transformers import CrossEncoder

model = CrossEncoder("jinaai/jina-reranker-m0", trust_remote_code=True)

scores = model.predict([
 ("A green car", "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg"),
 ("A bee on a flower", "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"),
 ("A green car", "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"),
])
print(scores)
# [0.9389156 0.96922314 0.46063158]

Retrieve and Rerank

A common pattern is to use an embedding model for fast initial retrieval, then refine the top results with a reranker:

from sentence_transformers import SentenceTransformer, CrossEncoder

# Step 1: Retrieve with an embedding model
embedder = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B", revision="refs/pr/23")

query = "revenue growth chart"
query_embedding = embedder.encode_query(query)

# Pre-compute corpus embeddings (do this once, then store them)
document_screenshots = [
 "path/to/doc1.png",
 "path/to/doc2.png",
 # ... potentially millions of document screenshots
]
corpus_embeddings = embedder.encode_document(document_screenshots, show_progress_bar=True)

# Simple cosine similarity retrieval, viable as long as embeddings fit in memory
similarities = embedder.similarity(query_embedding, corpus_embeddings)
top_k_indices = similarities.argsort(descending=True)[0][:10]

# Step 2: Rerank the top-k results with a reranker model
reranker = CrossEncoder("nvidia/llama-nemotron-rerank-vl-1b-v2", trust_remote_code=True)

top_k_documents = [document_screenshots[i] for i in top_k_indices]
rankings = reranker.rank(query, top_k_documents)
for rank in rankings:
 print(f"{rank['score']:.4f}\t{top_k_documents[rank['corpus_id']]}")

Since the corpus embeddings are pre-computed, the initial retrieval is fast even over millions of documents. The reranker then provides more accurate scoring over the smaller candidate set.

Input Formats and Configuration

Supported Input Types

Multimodal models accept a variety of input formats. Here's a summary of what you can pass to model.encode():

Checking Modality Support

You can check which modalities a model supports using the modalities property and supports() method:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qwen/Qwen3-VL-Embedding-2B", revision="refs/pr/23")

# List all supported modalities
print(model.modalities)
# ['text', 'image', 'video', 'message']

# Check for a specific modality
print(model.supports("image"))
# True
print(model.supports("audio"))
# False

The "message" modality indicates that the model accepts chat-style message inputs with interleaved content. In practice, you rarely need to use this directly. When you pass strings, URLs, or multimodal dicts, the model converts them to the appropriate message format internally. Sentence Transformers supports two message formats:

1. Structured (most VLMs, e.g. Qwen3-VL): Content is a list of typed dicts, e.g. [{"type": "text", "text": "..."}, {"type": "image", "image": ...}]
2. Flat (e.g. Deepseek-V3): Content is a direct value, e.g. "some text"

The format is auto-detected from the model's chat template.

Since all inputs get converted into the same message format internally, you can mix input types in a single encode() call:

embeddings = model.encode([
 # A text input
 "A green car parked in front of a yellow building",
 # An image input (URL)
 "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
 # A combined text + image input
 {
 "text": "A car in a European city",
 "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg",
 },
])

Processor and Model kwargs

You may want to control image resolution bounds or model precision. Use processor_kwargs and model_kwargs when loading the model:

model = SentenceTransformer(
 "Qwen/Qwen3-VL-Embedding-2B",
 model_kwargs={"attn_implementation": "flash_attention_2", "torch_dtype": "bfloat16"},
 processor_kwargs={"min_pixels": 28 * 28, "max_pixels": 600 * 600},
 revision="refs/pr/23",
)

processor_kwargs controls how inputs are preprocessed (e.g., image resolution bounds). Higher max_pixels means higher quality but more memory and compute. These are

The post Multimodal Embedding & Reranker Models with Sentence Transformers first appeared on Hard Wired.

Průvodce modely Claude od Anthropic

Úvod

Anthropic je americká firma, která se zabývá vývojem bezpečné AI - jejich hlavní produkt je rodina jazykových modelů Claude, v současnosti jedny z nejpokročilejších AI asistentů na trhu, které mají tři hlavní úrovně: Opus, Sonnet a Haiku. Když jsem poprvé začal s těmito modely pracovat, upřímně jsem nevěděl který kdy použít - všechny vypadaly podobně, ale rozdíly v kvalitě výstupu a ceně byly obrovské. V tomhle článku si projdeme co který model umí, kdy ho použít a proč, a sdílím zkušenosti z reálných projektů kde jsem každý z nich testoval.

Architektura rodiny Claude

Anthropic postavil třístupňovou hierarchii modelů, kde každá úroveň má svoje místo:

Všechny modely používají Constitutional AI framework pro bezpečnost a mají kontextové okno 200 000 tokenů (zhruba 150 000 slov), což v praxi znamená že můžeš nahrát celou kódovou bázi menšího projektu nebo technickou knihu a model si pamatuje všechno. Novější verze Opus a Sonnet nabízejí experimentální podporu až 1 milion tokenů - zkoušel jsem to s kompletní dokumentací ESP-IDF frameworku a fungovalo to překvapivě dobře, i když latence byla znatelně vyšší.

Claude Opus — hluboký myslitel

Co je Opus?

Opus je top tier model od Anthropic - navržený pro úlohy kde potřebuješ hluboké analytické uvažování, komplexní vícekrokové plánování, pokročilé programování a refaktoring, nebo práci s rozsáhlými kontexty jako jsou celé knihy nebo velké kódové báze. Když jsem poprvé testoval Opus na code review komplexní Flask aplikace s asynchronními tasky a Celery workers, byl jsem fascinovaný tím, jak model dokázal propojit souvislosti mezi moduly které byly od sebe vzdálené stovky řádků kódu a identifikovat potenciální race condition, kterou jsem já sám přehlédl.

Kdy použít Opus?

Ideální scénáře:

1. Code review před nasazením — Opus zachytí subtilní chyby jako memory leaky, async bugy nebo chybějící dispose volání, které ostatní modely přehlédnou
2. Architektonická rozhodnutí — Při návrhu systémové architektury nebo rozsáhlém refaktoringu
3. Výzkum a analýza — Sumarizace celých knih, analýza právních dokumentů, finanční modelování
4. Agentické workflow — Dlouhodobé autonomní úlohy vyžadující vícekrokové uvažování

Praktický příklad

Scénář: Máš komplexní Flask aplikaci s 50+ soubory a potřebuješ identifikovat 
bezpečnostní zranitelnosti.

Proč Opus: Model dokáže udržet kontext celé aplikace, propojit souvislosti mezi 
moduly a identifikovat zranitelnosti typu race condition nebo injection attacks, 
které vyžadují pochopení toku dat napříč celým systémem.

Cena

Opus 4.5 přinesl výrazné zlevnění oproti předchozím verzím (Opus 4/4.1 stál $15/$75), což zpřístupnilo prémiovou inteligenci širšímu spektru uživatelů - upřímně, při těch starých cenách jsem Opus používal jen na kritické review před nasazením do produkce, protože každý delší prompt stál dost peněz. Teď s novými cenami je to mnohem dostupnější, i když pořád ne na každodenní použití pokud máš omezený budget.

Claude Sonnet — spolehlivý kolega

Co je Sonnet?

Sonnet je vyvážený model - kombinuje vysokou inteligenci s rozumnou rychlostí a cenou, což z něj dělá ideální volbu pro většinu každodenní práce. Většina vývojářů tráví s tímhle modelem nejvíc času, a já nejsem výjimka - odhadem 80 % mých promptů jde na Sonnet, protože pro běžné programování, refaktoring nebo psaní dokumentace je naprosto dostačující a odpovídá rychle.

Kdy použít Sonnet?

Ideální scénáře:

1. Každodenní programování — Vývoj funkcí, práce s více soubory, správa stavu, připojení k API
2. Analýza a reporting — Strukturované analýzy, Q&A s dokumenty, vytváření reportů
3. Kreativní úlohy — Psaní obsahu, copywriting, technická dokumentace
4. Orchestrace agentů — Sonnet vytvoří plán a rozdělí úkoly pro Haiku instance

Praktický příklad

Scénář: Vyvíjíš React aplikaci s Tailwind CSS a potřebuješ implementovat
autentizaci s Firebase.

Proč Sonnet: Model zvládne multi-file logiku, správu stavu (Riverpod, Redux),
připojení k Firebase a generuje čistý, použitelný kód. Má vynikající výkon
v oblasti frontend/UI vývoje a generuje „pixel-perfect layouts".

Osobní zkušenost: Když jsem dělal redesign jednoho projektu s Flutter a Material 3,
Sonnet mi vygeneroval kompletní theme configuration včetně custom color schemes
a typography - kód fungoval na první pokus, což mě docela překvapilo protože
Material 3 API je dost komplexní a čekal jsem že budu muset něco ladit.

Cena

Sonnet nabízí výkon blížící se Opusu za zlomek ceny, což z něj dělá optimální volbu pro 90 % produkčních úloh - a tady je důležité si uvědomit že rozdíl mezi Sonnetem a Opusem není vždycky tak velký jak by se podle ceny mohlo zdát, takže pokud nejdeš do opravdu komplexních analýz nebo kritického code review, Sonnet ti bude stačit.

Claude Haiku — rychlý sprinter

Co je Haiku?

Haiku je nejrychlejší a nejlevnější model v rodině Claude - optimalizovaný pro minimální latenci (odpovědi pod sekundu), vysoký objem dotazů a nákladovou efektivitu. Upřímně, nejdřív jsem Haiku podceňoval a myslel si že je to jen "levná verze" pro lidi co chtějí ušetřit, ale když jsem ho začal používat na rychlé prototypování UI komponent, zjistil jsem že pro tento konkrétní use case je vlastně lepší než Sonnet - odpovídá skoro okamžitě a pro jednoduchý layout kód je kvalita naprosto dostačující.

Kdy použít Haiku?

Ideální scénáře:

1. Chatboti a zákaznická podpora — Real-time odpovědi bez čekání
2. UI prototypování — Rychlé generování layoutů a komponent
3. Klasifikace a moderace obsahu — Vysokoobjemové úlohy
4. Paralelní provádění subtasků — V orchestrovaném workflow s Sonnetem

Praktický příklad

Scénář: Potřebuješ rychle vytvořit Flutter screen s Material 3 designem.

Proč Haiku: Model vygeneruje layout téměř okamžitě. Pro brainstorming a rychlé
prototypy je ideální volbou. Ale pozor — v delších sessions „ztrácí nit"
a není vhodný pro komplexní logické stavby.

Osobní zkušenost: Zkoušel jsem s Haiku dělat složitější state management
s Riverpod providers a po třech čtyřech iteracích začal generovat kód který
nedával smysl - zapomínal na kontext z předchozích promptů a navrhoval řešení
která byla v rozporu s tím co jsme dělali předtím. Pro jednoduché úlohy super,
ale na komplexní logiku radši Sonnet.

Cena

Haiku je 5× levnější než Opus na vstupních tokenech, což z něj dělá ekonomickou volbu pro vysokoobjemové scénáře - pokud děláš chatbota nebo zákaznickou podporu kde potřebuješ zpracovat tisíce dotazů denně, rozdíl v ceně mezi Haiku a Sonnetem se rychle nasčítá na stovky dolarů měsíčně.

Srovnávací tabulka modelů

Orchestrační workflow — jak modely kombinovat

Když pracuješ na větším projektu, dává smysl kombinovat modely podle jejich silných stránek - tohle je něco co jsem se naučil až po pár měsících práce s Claude, protože na začátku jsem používal jen Sonnet na všechno a nevěděl jsem že můžu ušetřit čas i peníze tím že rozdělím úlohy mezi modely strategicky.

Fáze 1: Plánování (Sonnet)

Sonnet analyzuje požadavky, navrhuje architekturu a rozděluje úkoly na paralelizovatelné podúlohy.

Fáze 2: Implementace (Haiku)

Více instancí Haiku provádí subtasky paralelně — scaffolding, komponenty, API integrace.

Fáze 3: Review (Opus)

Před mergem provede Opus hlubokou revizi — zachytí async bugy, memory leaky a subtilní logické chyby.

Příklad z praxe:

Developer pracuje na mobilní aplikaci:
1. Používá Haiku pro rychlé UI prototypy
2. Přepne na Sonnet pro implementaci business logiky
3. Před releasem nechá Opus udělat finální code review

Výsledek: Opus odhalil rebuild issues a chybějící disposes,
které Haiku i Sonnet přehlédly.

Moje zkušenost: Přesně tenhle workflow jsem použil na jednom Flutter projektu
kde jsem dělal aplikaci pro správu IoT zařízení. Haiku mi vygeneroval asi 15
různých screen layoutů za pár minut, Sonnet implementoval komunikaci s MQTT
brokerem a state management, a Opus pak při finálním review našel memory leak
v subscription handleru který by v produkci způsobil problémy - model si všiml
že StreamSubscription není správně disposed při dispose() widgetu, což by
vedlo k postupnému nárůstu paměti. Tohle by Sonnet pravděpodobně přehlédl.

Rozhodovací strom: Který model zvolit?

START
  │
  ├── Je úloha časově kritická (real-time)?
  │     └── ANO → HAIKU
  │
  ├── Je to rutinní práce (coding, analýza, psaní)?
  │     └── ANO → SONNET
  │
  ├── Vyžaduje hluboké uvažování nebo rozsáhlý kontext?
  │     └── ANO → OPUS
  │
  ├── Je to finální review před nasazením?
  │     └── ANO → OPUS
  │
  └── Nejste si jistí?
        └── Začněte se SONNET, eskalujte na OPUS při potřebě

Cenové předplatné pro běžné uživatele

Pro ty, kteří nepoužívají API, nabízí Anthropic předplatné:

Praktické tipy pro optimalizaci nákladů

1. Začni s Haiku, eskaluj nahoru

Pro většinu dotazů postačí Haiku - na Sonnet nebo Opus přepni pouze pro složitější úlohy, což ti ušetří peníze a zároveň nezpomalí workflow, protože Haiku odpovídá tak rychle že rozdíl v latenci je znatelný.

2. Využij Prompt Caching

Při opakovaném dotazování na stejný kontext (např. velký dokument) snížíš náklady až o 90 % - tohle je obrovská úspora pokud pracuješ s rozsáhlou kódovou bází nebo dokumentací, protože model si cachuje kontext a při dalších dotazech ho nemusí znovu zpracovávat. Zkoušel jsem to s dokumentací k ESP-IDF a rozdíl v ceně byl dramatický - první prompt stál normálně, ale následující dotazy byly skoro zadarmo.

3. Batch API pro neurgentní úlohy

Asynchronní zpracování přes Batch API poskytuje 50% slevu na tokeny.

4. Optimalizuj prompty

Každý token stojí peníze. Odstraň zbytečný kontext a buď konkrétní.

Závěr

Každý model v rodině Claude má svoje místo:

• Opus je senior architekt — pomalejší, ale nejspolehlivější pro kritické rozhodnutí a hluboké analýzy
• Sonnet je spolehlivý kolega — zvládne 90 % každodenní práce kvalitně a efektivně, což z něj dělá můj go-to model
• Haiku je rychlý junior — ideální pro opakované úlohy a prototypování, překvapivě schopný pokud víš jak ho použít

Nejde o to používat jeden model na všechno. Jde o to strategicky kombinovat jejich silné stránky podle toho, co zrovna potřebuješ - a tohle pochopení přišlo až s praxí, protože na začátku jsem dělal chybu že jsem používal Sonnet i na úlohy kde by Haiku stačil, nebo naopak jsem se snažil ušetřit a používal Sonnet na code review kde by Opus odvedl mnohem lepší práci. Teď po několika měsících práce s těmito modely mám docela dobrý cit kdy který použít, a doufám že tento článek ti pomůže zkrátit tu learning curve.

Zdroje a další čtení

• Anthropic dokumentace
• Claude.ai
• API cenový přehled

Pro opravu diakritiky a překlepů byl použit model Claude Sonnet 4.5.

Článek aktualizován: březen 2026

The post Průvodce modely Claude od Anthropic first appeared on Hard Wired.

Context Engineering: Nová disciplína, která mění pravidla AI

Jak jsem se naučil, že úspěch AI aplikací nezávisí na dokonalém promptu, ale na tom, co model "vidí" kolem něj

Před třemi lety jsem trávil hodiny ladění promptů. Psal jsem stránkové instrukce, experimentoval s různými formulacemi, testoval desítky variant. A přesto můj AI asistent zapomínal klíčové informace z předchozích konverzací, můj kódovací pomocník ztrácel přehled o architektuře projektu a RAG systém nedokázal propojit souvislosti napříč dokumenty.

Pak jsem pochopil zásadní věc: problém nebyl v tom, jak jsem se modelu ptal, ale v tom, co všechno model věděl v okamžiku, kdy odpovídal. Objevil jsem context engineering – disciplínu, která překračuje hranice prompt engineeringu a mění celou hru.

Proč prompt engineering přestal stačit

Když poprvé otevřete ChatGPT, připadá vám to jednoduché: napíšete otázku, dostanete odpověď. Jenže reality produkčních AI aplikací je jiná. Představte si, že stavíte AI asistenta pro zákaznický servis. Potřebuje:

• Znát historii všech předchozích interakcí s klientem
• Mít přístup k aktuálním informacím o produktech
• Rozumět firemním procesům a pravidlům
• Pamatovat si kontext celé konverzace
• Umět zavolat externí API pro ověření dat

Žádný prompt, ať je sebevíc dokonalý, to sám nezvládne. Potřebujete systém, který modelu poskytne správný kontext ve správný čas. To je podstata context engineeringu.

Co je context engineering v praxi

Context engineering je disciplína navrhování a budování systémů, které orchestrují všechny informace, nástroje a paměť potřebné k tomu, aby AI dokázala řešit složité, real-world úkoly.

Nejde jen o prompt. Jde o celý informační ekosystém kolem modelu.

Reálný příklad z mé praxe

Nedávno jsem stavěl AI asistenta pro právní kancelář. Klasický přístup by byl:

Jsi právní expert. Odpovídej na otázky klientů o smluvním právu.

Context engineering přístup vypadal takto:

1. Systémový kontext:

Role: Senior právní poradce specializující se na obchodní právo
Firma: [název], 15 let praxe, focus na SaaS a tech startupy  
Regulatory environment: České právo, EU regulace

2. Dynamický retrieval:

# Při každé otázce systém:
query = user_question
relevant_cases = vector_search(query, case_database)
current_legislation = api_call("legal_updates", query)
client_history = get_client_context(client_id)
firm_templates = search_templates(query)

3. Paměťový systém:

# Kontext se skládal z:
- Dlouhodobé paměti klienta (preference, předchozí případy)
- Krátkodobé paměti konverzace (co už probrali dnes)
- Faktual knowledge base (zákony, judikáty)
- Tool access (kalkulačky poplatků, termíny soudů)
- Meta-context (urgence, složitost případu)

Výsledek? Místo obecných právních rad model poskytoval konkrétní doporučení založená na historii klienta, aktuální legislativě a firemních postupech.

Anatomie profesionálního context systému

1. Multi-layer memory architecture

Immediate context - co model "vidí" právě teď:

• Aktuální prompt a konverzace
• Výsledky z právě provedených nástrojů
• Dočasný stav úkolu

Session memory - co si pamatuje během práce:

• Historie kroků a rozhodnutí
• Předchozí výsledky a chyby
• Evoluce strategie řešení

Long-term memory - trvalé znalosti:

• User profily a preference
• Learnt patterns a insights
• Firemní knowledge base

2. Intelligent retrieval orchestration

Nejsložitější část. Systém musí v real-time rozhodnout:

• Které dokumenty jsou relevantní
• Jaké externí API zavolat
• Kolik kontextu použít (token limits)
• V jakém pořadí informace poskytovat

Můj workflow:

def build_context(user_query, session_state):
    # 1. Analýza query
    intent = classify_intent(user_query)
    entities = extract_entities(user_query)

    # 2. Multi-source retrieval
    docs = semantic_search(user_query, weight=0.4)
    tools = suggest_tools(intent, weight=0.3) 
    memory = get_relevant_memory(session_state, weight=0.3)

    # 3. Context assembly
    context = assemble_context(
        system_prompt=get_system_prompt(intent),
        retrieved_docs=docs[:5],  # Top 5 to stay within limits
        available_tools=tools,
        conversation_memory=memory,
        user_profile=get_user_context()
    )

    return context

3. Dynamic context optimization

Context není statický. Mění se podle:

Task complexity - složité úkoly potřebují víc kontextu
User expertise - expert vs. beginner potřebuje jiné informace
Performance feedback - učení se z úspěchů a chyb
Resource constraints - tokens, latency, costs

Praktické techniky z praxe

Context Layering

Místo jednoho obřího promptu stavím kontext po vrstvách:

# Layer 1: Core identity
system_role = """
Senior business analyst s 10+ lety zkušeností
Specializace: SaaS metriky, customer analytics
Styl: Data-driven, konkrétní doporučení
"""

# Layer 2: Current task context  
task_context = f"""
Aktuální projekt: {project_name}
Deadline: {deadline}
Stakeholders: {stakeholder_list}
Previous insights: {session_memory}
"""

# Layer 3: Dynamic information
dynamic_context = f"""
Relevantní data: {retrieved_data}
Dostupné nástroje: {available_tools}
Aktuální metrics: {live_metrics}
"""

Context Chaining

Pro komplexní úkoly rozdělím práci do kroků, kde výstup jednoho kroku se stává kontextem pro další:

# Krok 1: Analýza problému
problem_analysis = llm_call(
    context=base_context + user_problem,
    task="Analyzuj problém a identifikuj klíčové otázky"
)

# Krok 2: Sběr dat s kontextem z kroku 1
data_context = base_context + problem_analysis
retrieved_data = gather_data(problem_analysis.key_questions)

# Krok 3: Řešení s full kontextem
solution = llm_call(
    context=data_context + retrieved_data,
    task="Navrhni řešení založené na analýze a datech"
)

Adaptive Context Compression

Když se blížím k token limitu, používám kompresní strategie:

def compress_context(context_items, max_tokens):
    if calculate_tokens(context_items) <= max_tokens:
        return context_items

    # Prioritizace podle důležitosti
    prioritized = rank_by_relevance(context_items)

    # Postupná komprese
    compressed = []
    token_budget = max_tokens

    for item in prioritized:
        if item.type == "critical":
            compressed.append(item)  # Vždy zahrnout
        elif item.type == "supporting":
            if token_budget > estimate_tokens(item):
                compressed.append(summarize(item))  # Komprese

    return compressed

Časté problémy a jejich řešení

Context Poisoning

Problém: Chyba se dostane do kontextu a pak se propaguje dál.

Řešení z praxe:

def validate_context(context_item):
    # Fact-checking pro kritické informace
    if context_item.type == "factual":
        confidence = fact_check(context_item.content)
        if confidence < 0.8:
            context_item.add_disclaimer("Unverified information")

    # Timestamp check pro časově citlivé info
    if context_item.age > MAX_STALENESS:
        refresh_data(context_item)

    return context_item

Context Overload

Problém: Příliš mnoho informací rozptyluje model.

Mé řešení:

• Používám "attention hints" - explicitně říkám, na co se zaměřit
• Strukturuji kontext hierarchicky (nejdůležitější nahoře)
• Implementuji "context budgeting" - každý typ info má limit

context_budget = {
    "system_instructions": 500,   # tokens
    "user_input": 1000,
    "retrieved_docs": 2000,
    "tool_outputs": 1500,
    "memory": 1000
}

Tool Confusion

Problém: Model si vybírá špatné nástroje.

Moje strategie:

def smart_tool_selection(user_intent, available_tools):
    # Jen relevantní nástroje pro daný typ úkolu
    if user_intent == "data_analysis":
        return [tools.python_executor, tools.data_visualizer]
    elif user_intent == "web_research":
        return [tools.web_search, tools.summarizer]

    # Nikdy nedávat všechny nástroje najednou
    return filter_tools_by_relevance(available_tools, max_count=5)

Frameworky a nástroje

LangChain/LangGraph

Skvělé pro orchestraci workflows, ale pozor na over-engineering:

from langgraph import StateGraph

# Definuji workflow s explicitním context flow
workflow = StateGraph()
workflow.add_node("analyze", analyze_with_context)
workflow.add_node("retrieve", smart_retrieval) 
workflow.add_node("synthesize", synthesize_response)

# Context se propaguje mezi kroky
workflow.add_edge("analyze", "retrieve")
workflow.add_edge("retrieve", "synthesize")

LlamaIndex

Exceluje v knowledge management:

from llama_index import VectorStoreIndex, ContextBuilder

# Automatické budování kontextu
context_builder = ContextBuilder()
context_builder.add_memory_layer(user_profile)
context_builder.add_retrieval_layer(document_index)
context_builder.add_tool_layer(available_functions)

Anthropic MCP

Nejnovější standard pro propojení AI s externí systémy:

# MCP server pro firemní data
mcp_server = MCPServer()
mcp_server.register_resource("customer_db", CustomerDatabase())
mcp_server.register_tool("send_email", EmailTool())

# AI má strukturovaný přístup k firemním systémům

Budoucnost context engineeringu

Vidím tři hlavní trendy:

1. Automated Context Assembly
AI začíná samo rozpoznávat, jaký kontext potřebuje. Experiments s "self-reflective agents" ukazují zajímavé výsledky.

2. Multi-Modal Context Integration
Kombinace textu, obrázků, audio, video do jednotného kontextu. Pracuji na projektu, kde AI analyzuje video cally a extrahuje kontext pro další rozhodnutí.

3. Collaborative Context Networks
Více AI agentů sdílí kontext a buduje kolektivní "paměť" týmu.

Co si odnést domů

Context engineering není jen technická disciplína – je to nový způsob myšlení o AI aplikacích. Moje klíčová doporučení:

1. Začněte s auditem kontextu
Podívejte se na vaše současné AI aplikace. Co všechno model "nevidí", ale měl by?

2. Investujte do memory systémů
Dlouhodobá paměť je game-changer. AI, které si pamatuje vaše preference a zkušenosti, je kvalitativně jiné.

3. Experimentujte s context compression
Naučte se čistit a komprimovat kontext. Méně může být více.

4. Měřte context effectiveness
Trackujte, které části kontextu model skutečně používá. Optimalizujte na základě dat.

5. Myslĕte systémově
Context engineering je systémová disciplína. Nejde o izolované prompty, ale o architekturu informačních toků.

A především: context engineering je budoucnost AI aplikací. Kdo ho zvládne dřív, získá obrovskou výhodu.

Po několika letech experimentování s LLM si myslím, že context engineering je nejdůležitější skill pro AI builders. Není to jen o tom dát modelu správné informace – je to o pochopení toho, jak AI "myslí" a jak navrhnout systémy, které s tímto myšlením spolupracují. Je to fascinující kombinace software architecture, cognitive science a trochy magie.

The post Context Engineering: Nová disciplína, která mění pravidla AI first appeared on Hard Wired.

NVIDIA Project DIGITS: Revoluční superpočítač otevírá nové horizonty AI výzkumu

NVIDIA nedávno představila svůj průlomový kompaktní superpočítač Project DIGITS, který přináší bezprecedentní výpočetní výkon přímo na stůl vývojářů a výzkumníků umělé inteligence. Toto zařízení představuje zásadní pokrok v demokratizaci přístupu k vysoce výkonnému hardwaru pro AI a otevírá nové možnosti pro inovace v mnoha odvětvích.

Revoluční technické specifikace

Jádrem systému Project DIGITS je kombinace 20jádrového ARM procesoru NVIDIA Grace a GPU NVIDIA Blackwell, společně tvořících GB10 Grace Blackwell Superchip. Tento výkonný tandem, vybavený Tensor Cores 5. generace, poskytuje úctyhodný výkon až 1 petaflop při výpočtech s přesností FP4.

Pozoruhodná je i rozsáhlá paměťová kapacita 128 GB unifikované LPDDR5x paměti, doplněná úložným prostorem až 4 TB na NVMe SSD. Díky technologii ConnectX pro NVLink propojení lze navíc výkon zdvojnásobit spojením dvou jednotek, což umožňuje práci s modely obsahujícími až 405 miliard parametrů.

Klíčové specifikace v kostce

Procesor a GPU

• NVIDIA GB10 Grace Blackwell Superchip kombinující:
  • 20jádrový procesor NVIDIA Grace s architekturou ARM, optimalizovaný pro vysokou energetickou efektivitu
  • GPU NVIDIA Blackwell s Tensor Cores 5. generace, poskytující nekompromisní výkon pro AI modely

Výkon AI

• Až 1 petaflop AI výkonu s přesností FP4, umožňující trénování modelů s až 200 miliardami parametrů
• Možnost propojení dvou jednotek pro dosažení výkonu pro modely s až 405 miliardami parametrů

Paměť a úložiště

• 128 GB unifikované paměti LPDDR5x pro rychlý přístup k datům
• Až 4 TB NVMe SSD s vysokorychlostním čtením a zápisem

Konektivita

• Wi-Fi 6E a Bluetooth 5.3 pro bezdrátové připojení
• 2× USB4 Type-C pro rychlé přenosy dat
• Ethernet 10Gbps pro vysokorychlostní síťovou komunikaci
• ConnectX pro NVLink propojení mezi dvěma systémy Project DIGITS

Operační systém

• NVIDIA DGX Base OS založený na Ubuntu Linux, optimalizovaný pro AI a HPC aplikace

Potenciální využití v průmyslu a výzkumu

Ačkoliv je Project DIGITS primárně cílen na AI vývojáře, výzkumníky a datové vědce, jeho praktické využití bude pravděpodobně mnohem širší:

Biomedicínský výzkum

Project DIGITS může zásadně urychlit vývoj nových léčiv a terapeutických postupů. Schopnost analyzovat komplexní biologická data a predikovat interakce léčiv s proteiny může zkrátit časově náročné fáze farmaceutického výzkumu z let na měsíce. Výzkumná pracoviště a menší biotechnologické společnosti tak získají přístup k výpočetním kapacitám, které byly dříve vyhrazeny pouze velkým korporacím.

Průmyslová automatizace a optimalizace

Výrobní podniky mohou využít Project DIGITS k implementaci pokročilých algoritmů pro prediktivní údržbu a optimalizaci výrobních procesů. Vysoká výpočetní kapacita umožňuje zpracovávat data ze stovek senzorů v reálném čase a identifikovat potenciální závady dříve, než způsobí výpadky výroby.

Klimatický výzkum a modelování

Vědci zabývající se klimatickými změnami získají možnost vytvářet přesnější prediktivní modely lokálních klimatických jevů. Na rozdíl od globálních modelů, které vyžadují výpočetní kapacitu národních superpočítačových center, Project DIGITS umožní menším výzkumným týmům vytvářet detailní modely pro konkrétní geografické oblasti.

Autonomní systémy

Vývojáři autonomních vozidel a robotů budou moci lokálně trénovat a optimalizovat komplexní rozhodovací algoritmy bez nutnosti spoléhat se na cloudové výpočetní služby. To výrazně zkrátí vývojové cykly a zlepší bezpečnostní aspekty těchto systémů.

Vzdělávání a akademická sféra

S cenou 3 000 USD se Project DIGITS stává dostupným i pro univerzitní laboratoře a výzkumná pracoviště s omezeným rozpočtem. Tato cenová dostupnost umožní studentům a akademickým pracovníkům experimentovat s nejnovějšími AI modely a přispět k inovacím v oboru.

Použití a cílová skupina

Project DIGITS je ideální pro:

• AI vývojáře: Rychlé prototypování a testování modelů
• Výzkumníky: Analýzu velkého množství dat a experimentální AI výzkum
• Datové vědce: Komplexní workflow zahrnující data science a AI aplikace

Je důležité poznamenat, že Project DIGITS není určen pro gaming nebo streamování. Jeho zaměření je striktně na AI vývoj a výzkum.

Technologie a spolupráce

Projekt vznikl ve spolupráci s MediaTekem, což pomohlo dosáhnout vysoké energetické efektivity. Zařízení je předinstalováno s:

• NVIDIA AI software stackem pro snadné nasazení modelů
• Podporou frameworků jako PyTorch a NVIDIA NeMo

Dostupnost a cena

• Cena: 3 000 USD
• Dostupnost: květen 2025

Výzvy a limitace

Přes všechny své přednosti má Project DIGITS i určitá omezení. Zařízení není koncipováno pro herní účely nebo streamování obsahu, což může být pro některé potenciální uživatele limitující. Dále, přestože výkon 1 petaflop představuje ohromující číslo, pro určité typy velmi rozsáhlých modelů (nad 405 miliard parametrů) bude stále potřeba využít distribuované výpočetní systémy.

Energetická efektivita, kterou NVIDIA zdůrazňuje díky spolupráci s MediaTekem, bude klíčovým faktorem pro reálné nasazení. Detailní údaje o spotřebě energie a tepelném výkonu však zatím nebyly zveřejněny, což bude důležité sledovat před plánovaným uvedením na trh v květnu 2025.

Budoucí perspektivy

Project DIGITS signalizuje významný posun v přístupu k AI výpočetním kapacitám. Kombinace superpočítačového výkonu, kompaktních rozměrů a relativně dostupné ceny vytváří novou kategorii zařízení, která může zásadně změnit způsob, jakým organizace přistupují k AI výzkumu a vývoji.

S rostoucí poptávkou po výkonné výpočetní technice pro generativní AI a velké jazykové modely přichází Project DIGITS ve strategicky důležitém okamžiku. Přesouvá těžiště AI výpočtů z centralizovaných datových center zpět do rukou jednotlivých vývojářů a menších týmů, což může akcelerovat inovace a demokratizovat přístup k pokročilým AI technologiím.

Závěr

NVIDIA Project DIGITS představuje revoluci v AI vývoji. Nabízí superpočítačový výkon v kompaktním provedení za dostupnou cenu, což usnadní vývojářům a vědcům pracovat s pokročilými modely AI. Tento krok NVIDIA posiluje trend demokratizace AI technologií a přístupu k výkonnému AI hardwaru pro širší komunitu.

Pro profesionály v oboru AI, datové vědy a výpočetní techniky představuje Project DIGITS zařízení, které bude definovat novou éru decentralizovaného high-performance computingu pro umělou inteligenci.

The post NVIDIA Project DIGITS first appeared on Hard Wired.