Practical Artificial Intelligence Development With Racket

Preface

1. Requests from the Author
2. License for Book Manuscript: Creative Commons
3. Book Example Programs
4. Racket, Scheme, and Common Lisp
5. Personal Artificial Intelligence Journey: or, Life as a Lisp Developer
6. Acknowledgements

Tutorial and Using Datastores

A Quick Racket Tutorial

1. Installing Packages
2. Installing Local Packages In Place
3. Mapping Over Lists
4. Hash Tables
5. Racket Structure Types
6. Simple HTTP GET and POST Operations
7. Using Racket ~/.racketrc Initialization File
8. Tutorial Wrap Up

Datastores

1. Accessing Public RDF Knowledge Graphs - a DBPedia Example
2. SQlite
3. Optional Practice Problems

Implementing a Simple RDF Datastore With Partial SPARQL Support in Racket

1. 1. Core RDF Data Structures and Basic Operations
2. 2. Query Parsing and Execution
3. 3. Helper Functions and Utilities
4. 4. How a Join Actually Runs, Step by Step
5. 5. Saving and Loading Triples: N-Triples Persistence
6. 6. Adding FILTER to the Engine
7. 7. Testing the Engine
8. Conclusion
9. Optional Practice Problems

Webscraping and Browser Use

Web Scraping

1. Getting Started Web Scraping
2. Implementation of a Racket Web Scraping Library
3. Optional Practice Problems

Interfacing with External Programs: A Lightpanda Browser Client

1. The Problem: JavaScript-Rendered Web Content
2. Project Structure
3. Configuration
4. Running External Programs with subprocess
5. HTML Parsing: Extracting Links
6. The Main API Function
7. Helper Functions
8. Usage Examples
9. Key Racket Takeaways
10. Optional Practice Problems

Large Language Models

Building a MicroGPT in Racket

1. Introduction
2. Demystifying the Core Components
3. Conclusion
4. Complete Source Code Listing for microgpt.rkt
5. Wrap Up
6. Optional Practice Problems

Using the Google Gemini, OpenAI, Anthropic, Mistral, and Local Large Language Model APIs in Racket

1. The Cambrian Explosion in Language Technology: A Historical Trajectory
2. Commercial and Open Weight LLMs
3. Introduction to the Applications of LLMs
4. A Uniform API for LLMs in Racket: llmapis.rkt
5. Dedicated Provider Modules and Proprietary Features
6. Architecture and File Organization
7. Examples Using William J. Bowman’s Racket Language LLM
8. Optional Practice Problems

Ollama Tools/Function Calling in Racket

1. How Tool Calling Works
2. A Racket Tools Library
3. Complete Example Using the Tools Library and Example Tools
4. Writing Your Own Tools
5. Testing Tools Without a Running Ollama Server
6. Safety and Sandboxing
7. Design Tips for Your Own Tools
8. Summary
9. Optional Practice Problems

A Racket Coding Agent

1. The Agentic Loop
2. Module Architecture
3. The Provider-Agnostic Agentic Loop
4. The Fireworks AI Client
5. The MLX Client
6. Hierarchical Provider Configuration
7. The Tool Registry
8. The Approval and Diff System
9. Web Search Integration
10. The Main REPL
11. The Command-Line Interface
12. Running the Agent
13. Interpreting the Output
14. Wrap Up
15. Optional Practice Problems

Retrieval Augmented Generation of Text Using Embeddings

1. Example Implementation
2. What an Embedding Actually Is
3. Chunking: the Most Underrated Part of RAG
4. Retrieval, Without Thresholds
5. Testing the Pipeline
6. Production Notes
7. Retrieval Augmented Generation Wrap Up
8. Optional Practice Problems

Agentic RAG Using the Gemini API

1. Architecture
2. Embeddings and Vector Math
3. The Vector Store
4. The Agents
5. Running the Demo
6. Testing Without the Network
7. Wrap Up
8. Optional Practice Problems

Deep Learning, Natural Language Processing and Knowledge Graphs

Deep Learning in Racket with Malt: From XOR to a Two-Tower Recommendation System

1. Why neural networks and why XOR first?
2. The Malt mental model
3. Every malt function used in this chapter, defined
4. Example 1: XOR, the smallest non-linear problem
5. Example 2: Two hidden layers learn a curved boundary
6. Example 3: A jointly learned two-tower recommender
7. Interlude: the bug that made the model learn nothing
8. Malt survival guide (hard-won)
9. Files in this directory

Category-Theory Deep Learning in Racket

1. Why category theory for machine learning
2. The mathematics of the five perspectives
3. The data
4. Implementation
5. Running the code
6. Interpreting the results
7. Summary

Reinforcement Learning in Racket: Bandits, Q-Learning, Policy Gradients and DQN

1. The three problems in one picture
2. Part 1: Multi-armed bandits
3. Part 2: Tabular temporal-difference control
4. Part 3: Policy gradient methods
5. Part 4: Deep Q-Networks
6. Where the sharp edges are
7. Exercises

Natural Language Processing

1. NLP Wrap Up
2. Optional Practice Problems

Knowledge Graph Navigator

1. Entity Types Handled by KGN
2. KGN Implementation
3. Knowledge Graph Navigator Wrap Up
4. Optional Practice Problems

Rule Based Symbolic AI Systems

Implementing OPS5 in Racket: A Forward-Chaining Production System

1. Production Systems and Forward Chaining
2. The Rete Algorithm
3. Conflict Resolution
4. The OPS5 Language
5. The Example Programs
6. The Racket Conversion: One File of Pure Code
7. The Top-Level Commands as Macros
8. Compiling a Production into the Network
9. The Network Interpreter
10. Working Memory
11. The Recognize-Act Loop
12. Running the RHS
13. Running the Code
14. Interpreting the Results
15. Wrap Up
16. Optional Practice Problems

Logic Programming with Racklog: Two Classic Problems Revisited

1. Forward Chaining vs. Backward Chaining
2. Problem One: Analyzing a Card Hand
3. Problem Two: The Monkey and the Bananas
4. Wrapping Up
5. Exercises

Miscellaneous Short and Interesting Projects

Computing Pi and e: Fourteen Classical Algorithms in Exact Arithmetic

1. The Oldest Calculation in Mathematics
2. A Tour of the Algorithms
3. The Program at a Glance
4. Part 1: File Header and Exports
5. Part 2: The Fixed-Point Number Helpers
6. Part 3: The Pi Algorithms
7. Part 4: The Algorithms for e
8. Part 5: Reference Values and the Registry Scaffolding
9. Part 6: The Method Registry
10. Part 7: Reporting, the Console UI, and the Command Line
11. The Test Suite
12. Running the Code
13. Interpreting the Results
14. Wrap Up
15. Optional Practice Problems

Conclusions