Practical Artificial Intelligence Programming With Clojure

Practical Artificial Intelligence Programming With Clojure

Mark Watson
Buy on Leanpub

Table of Contents

Practical Artificial Intelligence Programming With Clojure

  • Cover Material, Copyright, and License
  • Preface
    • Requests from the Author
    • Clojure, With Some Java and Python
    • Personal Artificial Intelligence Journey: or, Life as a Lisp Developer
    • Notes for Setting Up Clojure, Emacs, and Cider
    • Acknowledgements
  • Deep Learning Using Deeplearning4j
    • Feed Forward Classification Networks
    • Optional Material: Documentation for Other Types of DeepLearning4J Built-in Layers
    • Deep Learning Wrap Up
  • Natural Language Processing Using OpenNLP
    • Using the Clojure and Java Wrappers for OpenNLP
  • Using uv and Python/Clojure Interoperation Using the libpython-clj2 Library
    • Setting Up the Project with uv
    • Using spaCy for Natural Language Processing
    • Using the Hugging Face Transformer Models for Question Answering
    • Combined spaCy and Transformer Question Answering
    • Using libpython-clj with the spaCy and Hugging Face Transformer Python NLP Libraries
  • Semantic Search Using a Vector Database and Python and uv Interoperability
    • What Is a Vector Database?
    • Architecture Overview
    • Setting Up the Project with uv
    • The Python Wrapper: vector_db.py
    • The Clojure Orchestration Layer: core.clj
    • Running the Demo
    • Note on the Model Cache
    • Wrap Up
  • Anomaly Detection Machine Learning Example
    • Motivation for Anomaly Detection
    • Math Primer for Anomaly Detection
    • AnomalyDetection Utility Class Written in Java
    • Clojure Experiment for the University of Wisconsin Cancer Data Using Java Anomaly Detection Code
  • Web Scraping
    • Web Scraping Using the jsoup Library
  • Using the Brave Search APIs
    • Setting an Environment Variable for the Access Key for Brave Search APIs
    • Using the Brave Search API
    • Wrap-up
  • Background Material for the Semantic Web and Knowledge Graphs
    • Learning Plan
    • Available Tools
    • RDF: The Universal Data Format
    • Extending RDF with RDF Schema
    • The SPARQL Query Language
    • OWL: The Web Ontology Language
    • Semantic Web Wrap-up
  • Clojure Wrapper for the Jena RDF and SPARQL Library
  • Simple RDF Datastore and Partial SPARQL Query Processor
    • Implementing a Simple RDF Datastore
    • Querying the RDF Datastore
    • Implementing a Partial SPARQL Query Processor
    • Putting It All Together: Running Example Queries
    • Summary
  • Knowledge Graph Navigator
    • Entity Types Handled by KGN
    • KGN Implementation
  • Datomic Local: Clojure wrapper for Immutable Datalog
    • Why Datalog for AI?
    • Project Setup
    • A Thin Wrapper
    • Database Lifecycle
    • Transactions
    • Schema Definition
    • Queries
    • Entity Relationships and Nested Pull
    • Join Queries
    • Upsert with Unique Identity
    • Transaction Operations
    • Time Travel: Querying Past States
    • Incremental Fact Building
    • Differences from Datomic Pro/Cloud
    • A Helper Function
    • AI & Knowledge Graph Use Cases
    • Running the Tests
    • Resources
  • Using the OpenAI APIs
  • Using the Google Gemini APIs
    • Test Code for REST Interface and Sample Test Output
    • Gemini API Library Implementation for REST Interface
    • (New) Gemini Client Library Using Google’s Java SDK for Gemini
    • Gemini APIs Wrap Up
  • Using the LiteLLM-CLJ Library as a Universal LLM Interface
    • Project Setup
    • How the Router Works
    • OpenAI Completions Example
    • Google Gemini Completions Example
    • When to Use LiteLLM-CLJ vs. Direct API Wrappers
    • Wrap Up
  • Question Answering Using OpenAI APIs and a Local Embeddings Vector Database
    • Implementing a Local Vector Database for Document Embeddings
    • Create Local Embeddings Vectors From Local Text Files with OpenAI GPT APIs
    • Using Local Embeddings Vector Database with OpenAI GPT APIs
    • Wrap Up for Using Local Embeddings Vector Database to Enhance the Use of GPT-5-nano APIs with Local Documents
  • Running LLMs Locally Using Ollama
    • Running the Example Tests
    • Clojure Client Library for the Ollama Service REST APIs
  • Using Moonshot’s Kimi K2 Model with Built In $web_search Tool Support
    • Clojure Library Moonshot.ai’s Kimi K2 Model (Including Web Search Tool)
    • Test code for the Moonshot.ai Kimi K2 API Client Library
    • Wrap Up for Moonshot.ai Kimi K2 Model
  • AgentScope Agent Oriented Framework
    • Overview of AgentScope
    • Generating Completions With AgentScope: Gemini Example
    • Multiple Tool Use with AgentScope: Ollama Example
    • Summary
  • Conclusions
Practical Artificial Intelligence Programming With Clojure/overview

Practical Artificial Intelligence Programming With Clojure

course_overview

count_chapters
begin_reading
download
p_implied_book_part_name

Practical Artificial Intelligence Programming With Clojure22 chapters

Begin ›
  1. Cover Material, Copyright, and License

  2. Preface

  3. Deep Learning Using Deeplearning4j

  4. Natural Language Processing Using OpenNLP

  5. Using uv and Python/Clojure Interoperation Using the libpython-clj2 Library

  6. Semantic Search Using a Vector Database and Python and uv Interoperability

  7. Anomaly Detection Machine Learning Example

  8. Web Scraping

  9. Using the Brave Search APIs

  10. Background Material for the Semantic Web and Knowledge Graphs

  11. Clojure Wrapper for the Jena RDF and SPARQL Library

  12. Simple RDF Datastore and Partial SPARQL Query Processor

  13. Knowledge Graph Navigator

  14. Datomic Local: Clojure wrapper for Immutable Datalog

  15. Using the OpenAI APIs

  16. Using the Google Gemini APIs

  17. Using the LiteLLM-CLJ Library as a Universal LLM Interface

  18. Question Answering Using OpenAI APIs and a Local Embeddings Vector Database

  19. Running LLMs Locally Using Ollama

  20. Using Moonshot’s Kimi K2 Model with Built In $web_search Tool Support

  21. AgentScope Agent Oriented Framework

  22. Conclusions