mkdir local-ai-wiki
cd local-ai-wiki
python3 -m venv venv
source venv/bin/activate # On Windows, use `venv\Scripts\activate`

pip install python-dotenv openai markdown

# .env
OPENAI_API_KEY="sk-your-openai-api-key-here"

# db_init.py
import sqlite3
import os

DATABASE_FILE = 'wiki.db'

def init_db():
    conn = sqlite3.connect(DATABASE_FILE)
    cursor = conn.cursor()

    cursor.execute('''
        CREATE TABLE IF NOT EXISTS documents (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,
            filepath TEXT UNIQUE NOT NULL,
            content TEXT NOT NULL,
            embedding BLOB,
            last_modified TEXT NOT NULL
        )
    ''')
    conn.commit()
    conn.close()
    print(f"Database '{DATABASE_FILE}' initialized successfully.")

if __name__ == '__main__':
    init_db()

python db_init.py

mkdir wiki_content

<!-- wiki_content/linux_basics.md -->
# Linux Command Line Basics

## Navigating the File System
- `pwd`: Print Working Directory. Shows your current location.
- `ls`: List files in the current directory. Use `ls -l` for long format, `ls -a` for all files (including hidden).
- `cd <directory>`: Change Directory. `cd ..` moves up one level. `cd ~` goes to home.

## File Operations
- `touch <filename>`: Create an empty file.
- `cp <source> <destination>`: Copy files or directories.
- `mv <source> <destination>`: Move or rename files/directories.
- `rm <file>`: Remove (delete) a file. Use `rm -rf <directory>` with extreme caution to remove directories recursively.

## Permissions
- `chmod`: Change file permissions. E.g., `chmod +x script.sh` makes a script executable.
- `chown`: Change file ownership.

## Process Management
- `ps aux`: List running processes.
- `kill <PID>`: Terminate a process by Process ID.
- `top`: Interactive process viewer.

<!-- wiki_content/python_decorators.md -->
# Python Decorators Explained

Decorators in Python are a powerful and elegant way to modify or enhance functions or methods. They allow you to "wrap" another function, adding functionality before or after the wrapped function runs, without permanently modifying it.

## Basic Structure
A decorator is essentially a function that takes another function as an argument and returns a new function (or the modified original function).

```python
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

python ingest.py

# query.py
import sqlite3
import os
from dotenv import load_dotenv
from openai import OpenAI
import numpy as np

load_dotenv()

DATABASE_FILE = 'wiki.db'
EMBEDDING_MODEL = "text-embedding-ada-002"
OPENAI_CLIENT = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
CHAT_MODEL = "gpt-3.5-turbo" # Or gpt-4 if you prefer

def get_embedding(text, model=EMBEDDING_MODEL):
    """Generates an embedding for the given text using OpenAI API."""
    text = text.replace("\n", " ")
    response = OPENAI_CLIENT.embeddings.create(input=[text], model=model)
    return np.array(response.data[0].embedding) # Convert to numpy array for vector operations

def cosine_similarity(v1, v2):
    """Calculates cosine similarity between two vectors."""
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

def semantic_search(query_text, top_k=3):
    """Performs semantic search on the database."""
    query_embedding = get_embedding(query_text)
    if query_embedding is None:
        print("Failed to get embedding for query.")
        return []

    conn = sqlite3.connect(DATABASE_FILE)
    cursor = conn.cursor()

    cursor.execute("SELECT title, content, embedding FROM documents")
    documents = cursor.fetchall()

    results = []
    for title, content, embedding_bytes in documents:
        # Convert BLOB back to numpy array
        doc_embedding = np.frombuffer(embedding_bytes, dtype=np.float32) # Ensure correct dtype
        similarity = cosine_similarity(query_embedding, doc_embedding)
        results.append((title, content, similarity))

    conn.close()

    # Sort by similarity in descending order and return top_k
    results.sort(key=lambda x: x[2], reverse=True)
    return results[:top_k]

def ask_llm(query, context_docs):
    """Asks the LLM a question based on retrieved context."""
    if not context_docs:
        return "No relevant documents found to answer your question."

    context = "\n\n".join([f"### {doc[0]}\n{doc[1]}" for doc in context_docs])

    messages = [
        {"role": "system", "content": "You are a helpful assistant for a personal knowledge base. Answer the user's question based *only* on the provided context. If the answer isn't in the context, say so gracefully."},
        {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {query}"}
    ]

    try:
        response = OPENAI_CLIENT.chat.completions.create(
            model=CHAT_MODEL,
            messages=messages,
            max_tokens=500,
            temperature=0.3 # Keep temperature low for factual answers
        )
        return response.choices[0].message.content.strip()
    except Exception as e:
        return f"Error communicating with LLM: {e}"

if __name__ == '__main__':
    while True:
        query = input("Ask your wiki (type 'quit' to exit): ")
        if query.lower() == 'quit':
            break

        print("\nSearching relevant documents...")
        relevant_docs = semantic_search(query, top_k=2) # Get top 2 most relevant documents

        if relevant_docs:
            print("\n--- Relevant Documents Found ---")
            for i, (title, _, sim) in enumerate(relevant_docs):
                print(f"{i+1}. {title} (Similarity: {sim:.4f})")
            print("--------------------------------")

            print("\nGenerating AI response...")
            # We pass the full content of the top documents to the LLM
            llm_response = ask_llm(query, relevant_docs)
            print("\n--- AI Response ---")
            print(llm_response)
            print("-------------------\n")
        else:
            print("No relevant documents found for your query.")

python query.py

# wiki.py
import argparse
import db_init
import ingest
import query
import os

def main():
    parser = argparse.ArgumentParser(description="Local AI Wiki CLI Tool")
    subparsers = parser.add_subparsers(dest='command', help='Available commands')

    # Init DB command
    parser_init = subparsers.add_parser('init-db', help='Initialize the SQLite database.')

    # Ingest command
    parser_ingest = subparsers.add_parser('ingest', help='Ingest Markdown files into the database.')
    parser_ingest.add_argument('--dir', type=str, default='wiki_content',
                                help='Directory containing Markdown files to ingest.')

    # Query command
    parser_query = subparsers.add_parser('query', help='Query the wiki using natural language.')
    parser_query.add_argument('query_text', nargs='?', type=str,
                                help='The natural language query to search for. If omitted, enters interactive mode.')
    parser_query.add_argument('--top-k', type=int, default=3,
                                help='Number of top relevant documents to retrieve for the AI response.')

    args = parser.parse_args()

    if args.command == 'init-db':
        db_init.init_db()
    elif args.command == 'ingest':
        ingest.ingest_all_markdown_files(args.dir)
    elif args.command == 'query':
        if args.query_text:
            print(f"Searching for: '{args.query_text}'")
            relevant_docs = query.semantic_search(args.query_text, top_k=args.top_k)
            if relevant_docs:
                print("\n--- Relevant Documents Found ---")
                for i, (title, _, sim) in enumerate(relevant_docs):
                    print(f"{i+1}. {title} (Similarity: {sim:.4f})")
                print("--------------------------------")

                print("\nGenerating AI response...")
                llm_response = query.ask_llm(args.query_text, relevant_docs)
                print("\n--- AI Response ---")
                print(llm_response)
                print("-------------------\n")
            else:
                print("No relevant documents found for your query.")
        else:
            # Interactive mode
            print("Entering interactive query mode. Type 'quit' to exit.")
            while True:
                user_query = input("Ask your wiki (type 'quit' to exit): ")
                if user_query.lower() == 'quit':
                    break

                print("\nSearching relevant documents...")
                relevant_docs = query.semantic_search(user_query, top_k=args.top_k)

                if relevant_docs:
                    print("\n--- Relevant Documents Found ---")
                    for i, (title, _, sim) in enumerate(relevant_docs):
                        print(f"{i+1}. {title} (Similarity: {sim:.4f})")
                    print("--------------------------------")

                    print("\nGenerating AI response...")
                    llm_response = query.ask_llm(user_query, relevant_docs)
                    print("\n--- AI Response ---")
                    print(llm_response)
                    print("-------------------\n")
                else:
                    print("No relevant documents found for your query.")
    else:
        parser.print_help()

if __name__ == '__main__':
    main()

# Initialize DB (if not already done)
python wiki.py init-db

# Ingest all markdown files
python wiki.py ingest

# Query directly from command line
python wiki.py query "how do python decorators work?"

# Enter interactive query mode
python wiki.py query