Will Ware wware

Turning a medical knowledge graph into a business

Created: 1/11/2026 8:31:47
Updated: 1/11/2026 9:21:53
Exported: 1/11/2026 9:22:47
Link: https://claude.ai/chat/0cc9b5d2-e022-48de-8ee8-1416f3a4688b

Prompt:

1/11/2026, 9:20:43 AM

https://claude.ai/chat/9b9c7509-3108-4cb0-a940-5a8fde8a9e4c

Great work on the pipeline refactoring! This is a solid Unix-style architecture with clean separation of concerns:

What you've built:

✅ Modular stages - Each pipeline script is independent and can be run separately
✅ Interface-based design - Storage, parsers, and embeddings all use ABC interfaces
✅ Swappable backends - SQLite for dev/testing, PostgreSQL+pgvector for production
✅ Clean data flow - Each stage reads/writes through well-defined interfaces
✅ Comprehensive docs - README and TESTING guide are clear and helpful

Medical Literature Knowledge Graph Schema Review

Date: 2026-01-02
Repository: wware/med-lit-graph
Reviewer: GitHub Copilot
Developer: wware

Initial Question

Medical research knowledge graph schema design

SQLite is perfect for a proof-of-concept. SQLModel works great with SQLite, and it's zero setup - just a file. Let me create a minimal but meaningful example that shows off the key concepts:

This will show:

✅ Entity types (Disease, Drug)
✅ Relationships with provenance
✅ Evidence tracking
✅ Type-safe queries
✅ The three-layer edge concept

GPU-Accelerated AI Tinkering

Like me, you may get tired of paying subscription fees to use online LLMs. Especially when, later, you're told that you've reached the usage limit and you should "switch to another model" or some such nonsense. The tempation at that point is to run a model locally using Ollama, but your local machine probably doesn't have a GPU if you're not a gamer. Then you dream of picking up a cheap GPU box on eBay and running it locally, and that's not a bad idea but it takes time and money that you may not want to spend right now.

There is an alternative, services like Lambda Labs, RunPod, and others. Lambda Labs is what I got when I threw a dart at a dartboard, so I'll be using it here.

I'm using a LLM to translate medical papers into a graph database of entities and relationships. I set up GPU-accelerated paper ingestion using Lambda Labs, and got an enormous speedup over CPU-only. The quick turnaround made it practical to find and fix some bugs discovered during testing.

GPU

Graph-RAG with Neo4j and MCP

A hands-on introduction to graph databases using Neo4j's classic movie dataset, accessible through both the Neo4j web interface and AI-powered natural language queries via Cursor IDE.

What Are Graph Databases?

Imagine you're organizing information about movies and actors. A traditional database stores these as separate tables:

Movies Table: Actors Table: Acted_In Table:

Immutable Interface Design (IID): Definition and Key Features

Immutable Interface Design (IID) is a proposed architectural pattern for Python development. The primary goals of this protocol are threefold:

Early and Specific Design Documentation: IID emphasizes defining comprehensive interface specifications before writing implementation code. This is achieved through the use of Python's abc module for interface classes, abstract methods with strict type annotations, detailed docstrings for all components, and frozen Pydantic models for immutable data structures[^0_2][^0_10]. This approach creates a clear blueprint, ensuring design details are captured early in the development process[^0_3][^0_6]. Static validation with tools like mypy further enforces type consistency from the outset.
Robust Guardrails for LLM Code Generation: The detailed and validated structure provided by IID serves as effective guardrails when using Large Language Models (LLMs) for code generation[^0_7][^0_11]

Vibe Coding Meets Test-Driven Development

The Convergence of Approaches

Vibe coding - the practice of writing code that "feels right" and follows natural patterns - might seem at odds with Test-Driven Development (TDD)'s rigorous, test-first methodology. However, when combined thoughtfully, these approaches can create exceptionally robust and maintainable code.

A Concrete Example: WebAuthn Implementation

The WebAuthn implementation showcased in this repository demonstrates how these methodologies can work together effectively:

Prompt:

The inverters in the upper left are a square wave oscillator (around 100 kHz), used to sense capacitive connectivity between X wires and Y wires. The comparators are TLV3404. Inputs A,B,C,D,E,F and outputs G,H,I are connected to an Adafruit Grand Central M4 controller board. Inputs D,E,F select one of eight options in the 4051 analog multiplexer, just prior to the 3-bit flash ADC that generates G,H,I.

Show me Rust code that would run on the Grand Central board to perform a keyboard scan.

Response:

I'll help you create Rust code for scanning this capacitive keyboard matrix. From the schematic, we're dealing with:

	.gradle/
	target/
	# btw the java files go in src/main/java/com/example/*.java