AI & LLM integration patterns
Call LLM APIs, structure prompts, parse responses, and ship AI features safely.
Circuit Breaker Pattern in Python for LLM API Calls
Implements a circuit breaker class that wraps LLM client calls to fail fast when the service is degrading, then recover automatically after a timeout.
import time
class CircuitBreaker:
def __init__(self, failure_threshold=3, recovery_timeout=5):
self.failure_threshold = failure_threshold
self.recovery_timeout = recovery_timeout
self.failure_count = 0
self.state = "closed"
self.last_failure_time = None
def call(self, …How to Append Few-Shot Examples to a Prompt in Python
This code builds a complete LLM prompt by appending few-shot examples in alternating user/assistant format using a simple loop.
def append_few_shot_examples(prompt: str, examples: list[tuple[str, str]], separator: str = "\n\n") -> str:
"""Append few-shot examples to a prompt in alternating user/assistant format."""
full_prompt = prompt
for user_input, assistant_output in examples:
full_prompt = f"{full_prompt}{separator}Use…How to Build a Data Helper for LLM Prompts in Python
A beginner-friendly helper class that flattens nested dictionaries, formats prompt templates, and safely parses JSON for AI/LLM pipelines.
import json
from typing import Any, Dict, List, Optional
class DataHelper:
"""Simple helper class for working with data in AI/LLM pipelines."""
def __init__(self, data: Optional[Dict[str, Any]] = None) -> None:
self.data = data or {}
def flatten(self, prefix: str = "") -> Dict[str, Any]…How to Build a Prompt Template with Variable Slots in Python
Create a reusable LLM prompt template with named variable slots using Python's string.Template class and fill them with render() calls.
from string import Template
class PromptTemplate:
def __init__(self, template_text):
self.template = Template(template_text)
def render(self, **kwargs):
return self.template.substitute(**kwargs)
if __name__ == "__main__":
template = PromptTemplate(
"You are a helpful assistant …How to Build a Simple Semantic Cache for Similar Prompts in Python
Mock a semantic cache that finds the closest matching prompt using word-overlap similarity and returns cached results above a threshold.
prompt_cache = [
"What is the capital of France?",
"How does recursion work?",
"Best practices for Python logging?",
"Explain binary search in one line.",
"How to reverse a string in Python?"
]
def normalize(text):
return " ".join(text.lower().split())
def similarity(a, b):
a_words = set(…How to Build a System-User-Assistant Message List in Python
Use dataclasses to model a chat conversation and build the system/user/assistant message list expected by LLM APIs.
from dataclasses import dataclass, field
from typing import List
@dataclass
class Message:
role: str
content: str
@dataclass
class Conversation:
messages: List[Message] = field(default_factory=list)
def add_system(self, content: str) -> None:
self.messages.append(Message(role="system", con…How to Build a Zero-Shot Classification Prompt in Python
Creates a prompt for zero-shot text classification by pairing input text with candidate labels and a hypothesis template.
from typing import Dict, List
def build_zero_shot_prompt(
text: str,
candidate_labels: List[str],
hypothesis_template: str = "This is about {}.",
) -> Dict[str, List[str]]:
"""Build a prompt ready for zero-shot classification."""
return {
"sequences": text,
"candidate_labels": can…How to Build an Agent Loop with Plan, Act, Observe in Python
Implements a simple plan-act-observe loop that an AI agent uses to iteratively complete a task in an environment while storing observations in memory.
class Agent:
def __init__(self, name):
self.name = name
self.memory = {}
def plan(self, task):
return f"Plan for {task}: step 1, step 2, step 3"
def act(self, plan, environment):
return f"Executing {plan} in {environment}"
def observe(self, action_result):
sel…How to Build an Entity Memory Dict to Store Facts in Python
Store and recall facts about entities using nested dictionaries with remember, recall, and forget functions in Python.
facts = {}
def remember(entity, attribute, value):
if entity not in facts:
facts[entity] = {}
facts[entity][attribute] = value
def recall(entity, attribute):
return facts.get(entity, {}).get(attribute, None)
def forget(entity, attribute=None):
if attribute is None:
facts.pop(entity, …How to Build an In-Memory Vector Store in Python
Build a lightweight in-memory vector store using a Python dict and cosine similarity for fast nearest-neighbor searches.
import math
from typing import Dict, List, Optional
class InMemoryVectorStore:
def __init__(self) -> None:
self.vectors: Dict[str, List[float]] = {}
self.index: Dict[str, List[str]] = {} # query -> list of ids sorted by similarity
def add(self, vector_id: str, vector: List[float]) -> None:
…How to Chunk a Long Document for RAG Retrieval in Python
Split text into overlapping chunks at sentence boundaries using a custom Python function suitable for RAG retrieval pipelines.
import re
from pathlib import Path
def chunk_document(text, chunk_size=500, overlap=100):
"""Split text into overlapping chunks suitable for RAG retrieval."""
# Normalize whitespace
text = re.sub(r'\s+', ' ', text).strip()
chunks = []
start = 0
while start < len(text):
end = min(s…How to Stream Tokens from a Mock LLM in Python
Simulate real-time LLM streaming by yielding tokens one at a time with a delay, making it easy to test streaming UIs.
import time
from typing import Generator
def stream_tokens(text: str, delay: float = 0.05) -> Generator[str, None, None]:
"""Simulate an LLM streaming tokens word by word."""
for word in text.split():
yield word
time.sleep(delay)
if __name__ == "__main__":
sample = "Hello world! This is…How to Validate LLM Output in Python
A beginner-friendly DataValidator class that checks required fields and type constraints on LLM-generated or user JSON data.
import json
from typing import Any, Dict, List, Optional
class DataValidator:
"""Simple helper for validating LLM-generated or user data."""
def __init__(self, required_fields: List[str], schema: Optional[Dict[str, str]] = None):
self.required_fields = required_fields
self.schema = schema or…How to build a function calling schema dict in Python
Build an OpenAI-compatible function calling schema dictionary with a helper function that takes name, description, parameters, and required fields.
import json
from typing import Dict, Any, List, Optional
def build_function_schema(
name: str,
description: str,
parameters: Optional[Dict[str, Any]] = None,
required: Optional[List[str]] = None
) -> Dict[str, Any]:
"""Build an OpenAI-compatible function calling schema dictionary."""
schema: …How to build a mock RAG pipeline in Python
Build a minimal Retrieval-Augmented Generation pipeline that retrieves the best-matching document by keyword overlap and generates a template-based answer.
def simple_rag_pipeline(question, documents):
"""
A minimal mock RAG pipeline: retrieve relevant context, then generate an answer.
"""
# Step 1: Retrieve — mock retrieval by simple keyword scoring
scores = []
for doc in documents:
doc_words = set(doc.lower().split())
question_wo…How to hash a prompt with SHA-256 in Python
Create a SHA-256 hex fingerprint of a prompt string, with a short-prefix variant for quick references.
import hashlib
def prompt_hash_fingerprint(prompt: str) -> str:
"""Return the full SHA-256 hex digest of the prompt."""
return hashlib.sha256(prompt.encode("utf-8")).hexdigest()
def short_fingerprint(prompt: str, length: int = 12) -> str:
"""Return a short prefix of the SHA-256 digest for quick reference…How to parse JSON in Python: A Beginner's Guide with Code Examples
This guide shows you how to parse JSON data in Python step by step, with practical code examples and expected outputs.
import json
from typing import Any, Dict, List, Optional
class DataHelper:
"""Beginner-friendly helper for common AI/LLM data tasks."""
def __init__(self, data: Optional[Dict[str, Any]] = None):
self.data = data or {}
def to_prompt(self, template: str) -> str:
"""Format a prompt…Prepare LLM prompt data with a Python helper class
A beginner-friendly Python class that collects records, converts them to JSON, and produces a quick summary for building LLM prompt context.
import json
from typing import Any, Dict, List
class DataHelper:
"""Simple helper to prepare data for LLM prompts."""
def __init__(self):
self.data = []
def add(self, item: Dict[str, Any]) -> "DataHelper":
self.data.append(item)
return self
def to_json(self) -> s…Browse by section
Each section groups closely related Python snippets.
AI & LLM integration patterns — Python code examples
What you will find here
This page collects ai & llm integration patterns snippets — short, copy-ready Python you can paste into our free online IDE and run without installing anything. Each sample includes a plain-English explanation and the full source code.
Samples vs tutorials and challenges
Samples are quick reference — one concept per page. For step-by-step teaching, use our Python tutorials. To test yourself, try quizzes or coding challenges. Clean up style with the Python formatter.