Project based Knowledge Base in one easy templated directory | Los Angeles .

Members-Only

Recent Talks & Demos are for members only

Exclusive feed

You must be an AI Tinkerers active member to view these talks and demos.

June 18, 2026 · Los Angeles

Project-Based Local Knowledge Base

Learn how to structure a project-based local filesystem knowledge base with agent-organized entries and indexing to avoid repeating work and optimize agent efficiency.

Overview
Tech stack
  • LLM
    Large Language Models (LLMs) are deep learning models, built on the Transformer architecture, that process and generate human-quality text and code at scale.
    LLMs are a class of foundation models: massive, pre-trained neural networks (often with billions to trillions of parameters) that leverage the self-attention mechanism of the Transformer architecture (introduced in 2017) to predict the next token in a sequence. Trained on vast datasets (e.g., Common Crawl's 50 billion+ web pages), these models—like GPT-4, Gemini, and Claude—acquire predictive power over syntax and semantics. They function as general-purpose sequence models, enabling critical applications such as complex content generation, language translation, and automated code completion (e.g., GitHub Copilot). Their core value: generalizing across diverse tasks with minimal task-specific fine-tuning.
  • JSON Canonicalization Scheme
    RFC 8785 defines a deterministic method for serializing JSON data to ensure consistent cryptographic hashes and digital signatures.
    JSON Canonicalization Scheme (JCS) solves the problem of data mutation during transit by enforcing a strict serialization format. It mandates lexicographical sorting of object keys, specific whitespace removal, and IEEE 754 double-precision mapping for numbers. By producing a single, predictable byte stream for any given JSON input, JCS allows developers to generate reliable HMACs and signatures without worrying about platform-specific formatting quirks. This standard is critical for security frameworks like JSON Web Proofs and decentralized identity systems.
  • In-Context Learning
    LLMs adapt to a new task by leveraging examples within the input prompt (few-shot prompting), eliminating costly parameter updates.
    In-Context Learning (ICL) is an emergent Large Language Model (LLM) capability: it allows models like GPT-3 to perform novel tasks based on demonstrations provided directly in the prompt (e.g., zero-, one-, or few-shot examples). The core mechanism involves conditioning the pre-trained model on this temporary context, which guides the output without requiring backpropagation or model weight updates. This approach delivers rapid, flexible task adaptation, significantly reducing the time and computational resources associated with traditional fine-tuning.
  • RAG
    RAG (Retrieval-Augmented Generation) is the GenAI framework that grounds LLMs (like GPT-4) on external, verified data, drastically reducing model hallucinations and providing verifiable sources.
    RAG is a critical GenAI architecture: it solves the LLM 'hallucination' problem by inserting a retrieval step before generation. A user query is vectorized, then used to query an external knowledge base (e.g., a Pinecone vector database) for relevant document chunks (typically 512-token segments). These retrieved facts augment the original prompt, providing the LLM (e.g., Gemini or Llama 3) the specific, current, or proprietary context required. This process ensures the final response is accurate and grounded in domain-specific data, avoiding the high cost and latency of full model retraining.
  • Chain-of-Thought
    Chain-of-Thought (CoT) is a prompt engineering technique that compels Large Language Models (LLMs) to articulate a series of intermediate reasoning steps, drastically improving performance on complex, multi-step tasks.
    CoT prompting unlocks advanced reasoning capabilities in LLMs, especially those over 100 billion parameters (e.g., PaLM 540B). The method is straightforward: include a few examples—or simply the phrase 'Let's think step by step' (Zero-Shot CoT)—that explicitly show the logical progression to the final answer. This forces the model to decompose complex problems, like intricate arithmetic or symbolic reasoning, into manageable, sequential steps. The result is a significant empirical gain in accuracy and a clear, auditable trace of the model's 'thought' process, moving performance beyond standard direct-answer prompting.