Rintcius Blok rintcius

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.

create-react-native-app purescript-app; cd purescript-app
pulp init --force
pulp build
src/Main.js

var React = require("react");
var RN = require("react-native");

exports.text = function(props){

map :: (a -> b) -> f a -> f b

for example for lists []

map :: (a -> b) -> [a] -> [b]

and for Maybe

map :: (a -> b) -> Maybe a -> Maybe b

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

Explaining Miles's Magic

Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.

But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.

For starters, here is the sort of thing that SI-2712 affects:

def foo[F[_], A](fa: F[A]): String = fa.toString

"A little bit of slope makes up for a lot of y-intercept"

01/13/2012. From a lecture by Professor John Ousterhout at Stanford, class CS140

Here's today's thought for the weekend. A little bit of slope makes up for a lot of Y-intercept.

[Laughter]

	"""
	The most atomic way to train and run inference for a GPT in pure, dependency-free Python.
	This file is the complete algorithm.
	Everything else is just efficiency.

	@karpathy
	"""

	import os # os.path.exists
	import math # math.log, math.exp

	module Main where

	import Prelude hiding (add)
	import Control.Monad.Eff (Eff)
	import Data.Function.Uncurried
	import Data.Array
	import Data.Foreign
	import Data.List as L
	import Data.Maybe (Maybe(..))
	import Data.Tuple

	// These lines go in ~/.sbt/0.13/global.sbt
	watchSources ++= (
	(baseDirectory.value * "*.sbt").get
	++ (baseDirectory.value / "project" * "*.scala").get
	++ (baseDirectory.value / "project" * "*.sbt").get
	)

	addCommandAlias("rtu", "; reload ; test:update")
	addCommandAlias("rtc", "; reload ; test:compile")
	addCommandAlias("ru", "; reload ; update")

	% sbtx dependencyGraph
	... blah blah ...
	[info] * Welcome to the sbt build definition for Scala! *
	[info] Check README.md for more information.
	[error] Not a valid command: dependencyGraph
	[error] Not a valid project ID: dependencyGraph


	% sbtx -Dplugins=graph dependencyGraph
	... blah blah ...