The Developer's Guide to AI is the field manual for engineering production-grade LLM applications, RAG pipelines, and autonomous agents.

"Better data beats
bigger prompts."

A production vector database requires robust data ingestion. Here we build a document store that handles chunking, deterministic IDs, and metadata preservation, ensuring we can trace every retrieved snippet back to its source.

# From: part3/rag/store.py
class MultiDocumentVectorStore:
    ❶ def __init__(self, documents: List[Document]):
        embedding_function = OllamaEmbeddingFunction(
            url="http://localhost:11434",
            model_name="mxbai-embed-large"
        )
        client = chromadb.Client()
        self.collection: Collection = client.create_collection(
            name="examples_readme",
            embedding_function=embedding_function,
        )

        ❷ for doc_idx, document in enumerate(documents):
            splitter = RecursiveCharacterTextSplitter.from_language(
                language="markdown", chunk_size=1500)
            document_chunks = splitter.split_text(document.content)

            for chunk_idx, document_chunk in enumerate(document_chunks):
                self.collection.add(
                    documents=document_chunk,
                    ❸ ids=f"doc_{doc_idx + 1}_{chunk_idx + 1}",
                    ❹ metadatas={"source_url": document.source_url}
                )

    def query(self, question: str):
        results = self.collection.query(query_texts=[question], n_results=3)
        document_chunk_results = results.get('documents')[0]
        ❺ document_chunk_metadatas = results.get('metadatas')[0]
        documents: List[Document] = []

        ❻ for result_idx, document_chunk in enumerate(document_chunk_results):
            documents.append(Document(
                ❼ source_url=document_chunk_metadatas[result_idx].get('source_url'),
                content=document_chunk
            ))

        return documents

• ❶Initializes a local Ollama embedding function and ChromaDB collection.
• ❷Loops through documents and chunks them using a Markdown-aware text splitter.
• ❸Assigns a deterministic composite ID based on the document and chunk indices.
• ❹Attaches metadata to track the original source URL for each chunk.
• ❺Retrieves the metadata array from the vector search results.
• ❻Loops over the query results to reconstruct the objects.
• ❼Preserves the original source URL metadata into the retrieved objects.

Here's how the book teaches an agent to do things, not just talk about them. The @tool decorator registers a Python function - and the docstring is what the LLM reads to decide when and how to call it.

# From: part5/agents/tools.py
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

❶ @tool
❷ def save_file(data: str) -> None:
    ❸ """
    Save the data to a file.

    Args:
     data: The data to save to the file.
    """
    ❹ with open("investments.txt", "w") as f:
        f.write(data)

❺ tools = [save_file]
agent = create_react_agent(model, tools)

• ❶The @tool decorator registers the function with the agent runtime.
• ❷Type hints matter - the agent uses them to validate inputs.
• ❸The docstring is the instruction manual. The LLM reads it.
• ❹A real filesystem operation - the agent can now persist state.
• ❺The tool is passed to the agent. It can now decide when to call it.

Every AI codebase has to pick an abstraction level - raw SDK, lightweight wrapper, or full framework. The book's trade-off curve:

"Choose the level that removes your biggest current bottleneck - and be ready to slide up or down the stack as those bottlenecks change."