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

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

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

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 Hugging Face 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. Using the OpenAI APIs in Racket
5. Using Google Gemini APIs in Racket
6. Using the Anthropic APIs in Racket
7. Using a Local Hugging Face Llama2-13b-orca Model with Llama.cpp Server
8. Using a Local Mistral-7B Model with Ollama.ai
9. Examples Using William J. Bowman’s Racket Language LLM
10. 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 Shared Interrupt Flag
4. The Provider-Agnostic Agentic Loop
5. The Fireworks AI Client
6. The Ollama Client
7. The Tool Registry
8. The Approval and Diff System
9. Web Search Integration
10. The Main REPL
11. Running the Agent
12. Interpreting the Output
13. Wrap Up
14. 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 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

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

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

Conclusions