AI Engineer Portal

Your personal operating system for career transition.

Private mode

Exercise

Build a prompt assembly pipeline

Build a Prompt Assembly Pipeline

Every LLM feature you ship assembles a messages array before making an API call. Doing this carelessly — concatenating strings, ignoring token counts, mixing trusted and untrusted content — is one of the most common sources of production bugs.

What you are building

Create an assemble_messages function that combines four components into a properly structured messages array:

System prompt — trusted instructions that go in the system role
User context — structured data about the current user (preferences, metadata) injected into the system block
Tool schemas — a list of tool definition dicts that will be passed to the API separately
Chat history — previous conversation turns that must be trimmed to fit a token budget

Requirements

Accept a max_history_tokens parameter and trim conversation history from the oldest end if the history exceeds this budget
Use a simple token estimate: len(text.split()) * 1.3 for word-based estimation
Always preserve the system prompt and the most recent user message in full
Return a PromptAssembly dataclass with messages, estimated_tokens, and tools_count fields
Raise ValueError if the system prompt alone exceeds max_history_tokens

Why this matters

Context budget management is the difference between a feature that works reliably in production and one that throws mysterious 400 errors when users have long conversations. Building this discipline in early pays dividends across every LLM feature you ship.

Llm Foundations / easy / Step 1 of 6

Practice stage

General drill

Hint

Keep the solution explicit and reviewable.

Next drill

Parse structured LLM output with fallback

Success criteria

Make the solution explicit, debuggable, and easy to explain.

Review checklist

Review where the boundary is, what gets validated, and what would be hard to debug later.

from __future__ import annotations

from dataclasses import dataclass, field
from typing import TypedDict

class Message(TypedDict):
    role: str
    content: str

@dataclass
class PromptAssembly:
    messages: list[Message]
    estimated_tokens: int
    tools_count: int

def estimate_tokens(text: str) -> int:
    """Simple word-based token estimate: words * 1.3."""
    # TODO: implement token estimation
    raise NotImplementedError

def assemble_messages(
    system_prompt: str,
    user_context: dict,
    tools: list[dict],
    chat_history: list[Message],
    max_history_tokens: int = 4000,
) -> PromptAssembly:
    """
    Assemble a messages array with token budget management.

Args:
        system_prompt: Trusted instructions for the model
        user_context: Structured user data injected into the system block
        tools: Tool definition dicts (returned in PromptAssembly, not in messages)
        chat_history: Previous conversation turns, trimmed to fit budget
        max_history_tokens: Maximum tokens for history portion

Returns:
        PromptAssembly with assembled messages and metadata
    """
    # TODO: validate that system prompt fits within budget
    # TODO: format user_context as a labeled block appended to system_prompt
    # TODO: trim chat_history from oldest end to fit max_history_tokens
    # TODO: assemble final messages list: [system, ...trimmed_history]
    # TODO: return PromptAssembly with messages, estimated_tokens, tools_count
    raise NotImplementedError

Practice

Generate a variation

Generate a new exercise variation to deepen understanding or practice a related concept.

Attempt history

Recent submissions

Before you submit, decide what a strong answer should make obvious to the reviewer.

No attempts yet.