Jon Karna jonkarna

LLM Wiki

A pattern for building personal knowledge bases using LLMs.

This is an idea file, it is designed to be copy pasted to your own LLM Agent (e.g. OpenAI Codex, Claude Code, OpenCode / Pi, or etc.). Its goal is to communicate the high level idea, but your agent will build out the specifics in collaboration with you.

The core idea

Most people's experience with LLMs and documents looks like RAG: you upload a collection of files, the LLM retrieves relevant chunks at query time, and generates an answer. This works, but the LLM is rediscovering knowledge from scratch on every question. There's no accumulation. Ask a subtle question that requires synthesizing five documents, and the LLM has to find and piece together the relevant fragments every time. Nothing is built up. NotebookLM, ChatGPT file uploads, and most RAG systems work this way.

My issues with Modules

In researching topics for RailsCasts I often read code in Rails and other gems. This is a great exercise to do. Not only will you pick up some coding tips, but it can help you better understand what makes code readable.

A common practice to organize code in gems is to divide it into modules. When this is done extensively I find it becomes very difficult to read. Before I explain further, a quick detour on instance_eval.

You can find instance_eval used in many DSLs: from routes to state machines. Here's an example from Thinking Sphinx.

class Article &lt; ActiveRecord::Base

Model Accessors

I really like this pattern for providing accessors to the models used in a controller. Alternatively, you usually see a before_filter to set the model from the params hash only on the actions that need it. IMO this is abusing a before_filter because the filter chain is for pre-processing the request. This does sort of make sense if you want to redirect away from the page gracefully if the record can't be found, but you can do that by just calling the accessor in a filter to make sure it's there.

This means that views are more like partials with locals, which is nice. It also means the accessor is as easy to test as a named filter. And as usual it pulls the method out of the action to share, which is also nice.

Also, it achieves the same ends as gems that try to OO the view, but without a gem and with terse code. The model can be swapped for a presenter if necessary.

Deploying Rails to Linode

Installing Ruby Enterprise Edition, Apache, MySQL, and Passenger for deploying Rails 3.0 applications.

Get a Linode, and set it up with Ubuntu 10.04 LTS so that you have till April 2013 to get updates. Once the Linode is formatted, boot it and continue on.

Set up an 'A' record in your DNS, pointing to the IP of your Linode. I'm using demo.napcs.com here.

	record = Post.new(:title => 'Yay', :body => 'This is some insert SQL')

	# easiest way to achieve this is by calling protected #arel_attributes_values (tested in
	# rails 3.2.13). the alternative is to build the entire insert statement using arel >_>
	record.class.arel_table.create_insert \
	.tap { \|im\| im.insert(record.send(:arel_attributes_values, false)) } \
	.to_sql

	class PostsController < ActionController::Base
	def create
	Post.create(post_params)
	end

	def update
	Post.find(params[:id]).update_attributes!(post_params)
	end

	private

	#############################################################################
	# Documentation #
	#############################################################################

	# Author: Todd Whiteman
	# Date: 16th March, 2009
	# Verion: 2.0.0
	# License: Public Domain - free to do as you wish
	# Homepage: http://twhiteman.netfirms.com/des.html
	#

	# Bulk API design
	#
	# resources :posts
	class PostsController < ActiveController::Base
	# GET /posts/1,4,50,90
	# post_url([ @post, @post ])
	def show_many
	@posts = Post.find(params[:ids])
	end