66 docs tagged with "Intermediate"

How AI agents store, retrieve, and reason over information across turns and sessions.

Best practices for writing system prompts that produce reliable, well-scoped AI agent behavior.

Claude's native function/tool calling mechanism using JSON schema definitions, tool_use and tool_result message types, with support for multi-turn tool use, parallel calls, and streaming.

Microsoft's multi-agent conversation framework enabling LLM-powered agents to collaborate via structured message exchanges, with built-in code execution and human-in-the-loop support.

Agents that operate with minimal human intervention.

Standard benchmarks for AI: GLUE, SuperGLUE, MMLU, and more.

Bidirectional Encoder Representations from Transformers.

Encoder-decoder predecessor to Gemini; denoising pretraining for summarization and generation.

DeepSeek AI's open-weight LLMs with strong reasoning and code; MoE and efficient scaling.

Alibaba's LLM family; multilingual, coding, and long-context support.

Step-by-step reasoning to improve LLM outputs.

Continuous integration and delivery adapted for machine learning — testing data, models, and code together.

Reusable, invocable prompt templates that extend Claude Code's capabilities — what skills are, how to write them, where to store them, and how to invoke them with /skill-name.

Enterprise-focused AI platform specializing in embeddings, reranking, and RAG for search and information retrieval at scale.

How Claude Code manages the context window across long sessions — automatic compression, conversation history strategies, and practical techniques for keeping sessions effective at scale.

Memory patterns for chat agents — buffer, summary, vector, and entity memory.

CNNs for spatial and image data.

Role-based multi-agent framework where agents have explicit roles, goals, and backstories, collaborating through structured tasks and crew processes.

An overview of data pipelines in the ML context — batch vs streaming, ETL vs ELT, data quality, and schema validation.

Git for data and models — versioning datasets, pipelines, and experiments alongside source code.

RL with deep neural networks for function approximation.

Chinese AI lab offering open-weights models with state-of-the-art reasoning and coding capabilities at significantly lower cost than proprietary alternatives.

Measuring model performance across tasks.

How to systematically log, compare, and reproduce ML experiments using tracking tools.

Adapting LLMs to specific tasks and domains.

Generative Pre-trained Transformer and decoder-only models.

Platform and libraries for models, datasets, and pipelines.

Hardware and systems for training and serving AI: GPUs, TPUs, clusters.

Framework for LLM applications and agents.

Stateful agent graphs built on LangChain, where nodes are Python functions, edges define routing, and a shared TypedDict state enables cycles, conditional branching, persistence, and human-in-the-loop checkpoints.

Data framework for LLM applications and RAG.

Running AI models on-device or on-premises instead of cloud APIs.

Meta's open-weights Llama model family — local deployment, third-party API hosting, fine-tuning, and the open vs. closed model debate.

Mistral AI's dual open-weights and commercial API platform — efficient models, multilingual strengths, and La Plateforme for enterprise use.

Comprehensive guide to monitoring machine learning models in production, covering concept drift, data drift, model decay, metrics, alerting strategies, and tooling.

Open-source platform for the complete ML lifecycle, covering experiment tracking, projects, models, and the registry.

Reducing model size and compute for deployment.

An open standard for connecting AI models to external tools, data sources, and services — enabling portable, interoperable tool use across any AI application.

Centralized store for versioning, staging, and governing ML model artifacts across their full lifecycle.

Strategies and frameworks for deploying ML models as scalable inference services — batch, real-time, and streaming.

Multiple agents collaborating or competing.

Models that process and generate across text, image, audio, and video modalities.

Cross-platform, high-performance inference engine for ONNX models with support for CPU, GPU, and NPU execution providers.

Architecture where one LLM creates a step-by-step plan and another executes each step independently.

Designing prompts to steer LLM behavior and improve outputs.

A technique that runs multiple structurally different prompt variations against the same LLM and aggregates their outputs, trading inference cost for higher accuracy and lower variance than any single prompt can achieve.

Deploy PyTorch models on mobile and edge devices using TorchScript and the next-generation ExecuTorch runtime.

Components and design choices in RAG systems.

Example RAG pipelines and code snippets.

Interleaving reasoning and action in agents.

How LLMs and agents structure reasoning and action.

RNNs and sequential data.

Combining retrieval with LLM generation for accurate, grounded answers.

Spec-driven reasoning pattern combining retrieval and decision design.

A prompting technique that generates multiple independent chain-of-thought reasoning paths and selects the final answer by majority vote, significantly improving reliability over single-pass chain-of-thought.

Search by meaning using embeddings and similarity.

Building AI systems from explicit specifications.

A two-step prompting technique that first asks the model a higher-level abstract question, then uses that abstraction as context to answer the original specific question — improving reasoning accuracy on complex tasks.

Token-by-token output for lower perceived latency and better UX.

Techniques for getting LLMs to produce machine-readable structured data — JSON mode, function calling schemas, and Pydantic-based extraction — enabling reliable integration into APIs and automated pipelines.

Hierarchical agents and delegation.

Lightweight runtime for on-device ML inference across Android, iOS, embedded systems, and microcontrollers.

Extended thinking in Claude Code — what it is, how effort levels affect reasoning depth versus speed, and how to configure thinking behavior for different task types.

Exploring multiple reasoning branches.

Storing and searching embeddings for RAG.

Cloud-native MLOps platform for experiment tracking, hyperparameter sweeps, artifact management, and collaborative reporting.