DEV Community: Luiza

The Culpeper Séance: An Offline RAG Séance with Nicholas Culpeper

Luiza — Fri, 30 Oct 2026 01:00:07 +0000

What I Built

The Culpeper Séance is an offline séance that channels Nicholas Culpeper (1616–1654)—the English herbalist and astrologer—so you can ask him about plants in the voice of a gentle, slightly eerie ghost. Answers are grounded in passages from his Complete Herbal (Project Gutenberg, public domain), not in whatever the model felt like inventing tonight.

When the ghost names a dangerous herb, a Beyond the Veil panel stamps a modern verdict: Folklore, Plausible, Harmful, or Deadly. Those toxicity claims come from a hand-curated verdicts.json file—they are never generated by the model at runtime.

The UI is a candlelit séance circle with streaming ghost text, a browsable grimoire of parsed herbs, and a poison cabinet for the scary ones. It maps almost line-for-line to the challenge prompt’s “offline séance chatbot” idea, except the spirit is a real dead author and his actual book.

Demo

Quick try for judges (local):

git clone https://github.com/myluco/CulpeperSeance.git
cd CulpeperSeance
cp .env.example .env
make setup
make ingest    # one-time: download Gutenberg text, chunk, embed into Chroma
make dev       # Flask API + Vite UI

Open the URL Vite prints (usually http://localhost:5173). Ensure Ollama is running, with ollama pull nomic-embed-text and a chat model such as gemma4:31b-cloud (after ollama signin if you use cloud-tagged models).

No login required. Sample questions:

“What herb might quiet a sleepless head?”
“Tell me of foxglove”
“What rules the stars over rosemary?”

Code

myluco / CulpeperSeance

The Culpeper Séance

Summon the ghost of Nicholas Culpeper (1616–1654) and ask him for herbal remedies. He answers in character, grounded in the actual text of The Complete Herbal, and a "Beyond the Veil" panel reports what modern science says (usually: please don't drink that).

Built for the Ghost in the Machine challenge with open pieces only: an open-weight model served by Ollama, LangChain + LangGraph, Chroma, and a public-domain book.

Layout

ui/       React + Vite + TypeScript front end            (own package.json)
server/   Flask API, SSE streaming                       (own pyproject.toml)
agent/    LangGraph agent: guard -> retrieve -> grade -> generate -> verdict
rag/      download, parse, chunk, embed, persist, retrieve (+ one-time ingest CLI)
data/     artifacts only, never code
  raw/        downloaded Gutenberg text (git-ignored)
  processed/  herbs.jsonl (canonical parsed herbs) + parse_report.json
  chroma/     persisted vector DB (git-ignored)
  verdicts.json  hand-curated modern verdicts (toxicity claims are never model-generated)

Dependencies flow one way: server ->…

View on GitHub

MIT licensed. Monorepo layout: rag/ (ingest + Chroma), agent/ (LangGraph), server/ (Flask + SSE), ui/ (React + Vite).

How I Built It

Open-weight and open-source AI are the engine, not decoration:

Layer	Open stack
Chat	Gemma 4 via Ollama (`CHAT_MODEL=gemma4:31b-cloud`)
Embeddings	nomic-embed-text via Ollama (local pull)
Agent	LangGraph + LangChain (`guard → retrieve → grade → generate → verdict`)
Vector store	Chroma (persisted under `data/chroma/`)
Corpus	Gutenberg Complete Herbal—parsed into `herbs.jsonl`, chunked, embedded once

RAG that respects the dead author. The ghost’s system prompt forbids herbs, doses, or facts not present in retrieved passages. A separate grade step asks the model yes/no whether the passages could answer the question; if not, the graph rewrites the query into 17th-century herbal vocabulary or falls back to a polite “the veil is too thick” refusal.

Safety without vibes-only guardrails. Before any retrieval, deterministic regex guardrails refuse self-harm, harm-to-others, and dosage questions—instant, testable, and not negotiable via prompt injection.

Streaming séance. POST /api/ask streams tokens over SSE so the UI can render the ghost word-by-word while the graph finishes and attaches verdict metadata.

Why not a closed API? The book is fixed public-domain text. Embeddings and the vector index live on your machine after make ingest. Swapping CHAT_MODEL or EMBED_MODEL in .env does not require rewriting application code—only re-ingest if you change the embed model.

Why Does Open Innovation Matter?

Culpeper has been dead for centuries; his book is public domain. A closed chat product could still hallucinate foxglove as harmless tea. This project ties the ghost to retrieved passages and curated modern verdicts so the spooky layer does not erase medical reality.

Open pieces also mean:

Privacy — After ingest, your herbal index and embeddings stay local; you are not shipping health questions to a proprietary log by default.
Longevity — Gutenberg and the repo outlive any single vendor API. If a hosted model tag changes, you point Ollama at another open-weight model and keep the same graph.
Offline-capable core — Embeddings run locally; chat can run through Ollama with cloud-tagged Gemma or a fully local model if you prefer air-gapped inference.
Inspectable safety — Guardrails and verdicts are plain code and JSON, reviewable in PRs, not hidden policy layers.

The line between past and present really is thinner here: a 1654 voice, a 2026 embedding model, and a UI that looks like you lit a candle with ghosts, witches and black cats flying around.

The Spirit of It

I built this because the Week 4 theme clicked for me all at once: mystery, the past, and that feeling that something old is still in the room with you. Ghost in the Machine is not only jump scares—it is memory, voices from another century, and stories that outlive the people who told them. A séance with Nicholas Culpeper fits that mood without forcing it. He is already a ghost in the historical sense, and his herbal is already a bridge between then and now.

Then there are the plants. I love them—the names, the folklore, the idea that a leaf or root once carried hope and danger in the same breath. Culpeper wrote the stars into every herb; the app lets me sit with that world for a while: candlelight, a question about foxglove or a restless night, and an answer that has to earn its place in the book before the ghost may speak it.

When the demo finally streamed the first reply word by word, it felt less like “AI output” and more like opening a door—uncertain, a little eerie, and rooted in something real that survived four hundred years. That is the moment I wanted. I am proud of this one.

For this Hacktoberfest, 2026, all apps I built for the challenges are garden-related, representing my love for gardening and software development.

Prize category

Best Use of Gemma — Gemma 4 is the model used, relevance grading, query rewrite, and in-character generation, all through Ollama’s open-weight distribution.

Disclosures

Parts of this post were drafted with AI assistance
AI-disclosure: some_ai

Yard Sloth: walk your yard once, let open agents babysit the garden

Luiza — Sat, 24 Oct 2026 16:37:33 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Yard Sloth is a local-first garden assistant for people who want a cared-for yard without becoming a part-time horticulture researcher.

You enter the name of plants in your yard (in the future, you will take one yard walk on your phone—snap photos), tag locations like "front bed, left of steps"—and confirm the plant list. From there, three cooperating agents:

Plant census — turns the name of a plant (in the future, turns photos + live web excerpts) into candidate plants with confidence scores (you stay in the loop before anything is saved).
Care calendar — spreads prune, feed, and protect tasks across the season and exports an .ics you can drop into any calendar app.
Frost watch — pulls tonight’s forecast and raises a banner when tender plants are at risk, with a checklist instead of panic-googling at 9 PM.

The sloth branding is intentional: the app is built for slow, steady laziness. You do the one walk; open models and agent workflows do the recurring mental load. You can use it every day to keep your yard in check. Urgent tasks are marked with an urgent icon, so you can see what you really need to do today.

Demo

Local demo: clone the repo, run python3 server/main.py and npm run dev, open http://localhost:3000. You will need Ollama running with the models configured in settings.

Video demo: https://youtu.be/AV80gnBCeYw

Code

myluco / YardSloth

App that advises what to do in the yard

Yard Sloth

Walk your yard once with your phone, confirm the plant list, and get a care calendar plus evening frost alerts. Everything runs locally on your own machine.

1. Project Directory Architecture

The repository divides responsibilities into distinct subsystems:


├── agents/             # CrewAI Agent & MCP Tooling Subsystem
│   ├── agent/         # Census, Calendar, and Frost watch agents
│   ├── assets/        # Agent personas, prompt templates & roles
│   ├── mcp/           # MCP tools (live web browsing for weather, frost, care rules)
│   ├── memory/        # Ephemeral in-memory session state (zero disk storage)
│   ├── main.py        # CrewAI pipeline coordinator
│   └── README.md      # Agents architecture documentation
│
├── server/             # 100% Pure Python HTTP Backend
│   ├── api/           # REST endpoint handlers (routes.py)
│   ├── server/        # Multithreaded HTTP server engine & network config
│   ├── main.py        # Python server entry point (python3 server/main.py)
│   └── README.md

…

View on GitHub

Public repo: github.com/myluco/YardSloth

All substantive work for this submission landed October 21–22, 2026 (initialize → LangGraph judge pipeline → task list polish), inside the Week 3 entry window.

How I Built It

Yard Sloth is open-source AI at the core, not a thin wrapper around a single chat API.

Layer	Tech	Role
LLM workflows	LangGraph (`dual_judge_graph.py`, plant-care workflow)	Parallel gather calls, then a judge merge
Inference	Ollama on your machine	Open-weight models; swappable via settings/env
Tools	MCP web browse	Live horticulture + Open-Meteo—no static `care_rules.json`
API	Pure Python `server/`	REST for the UI
UI	React + TypeScript	Yard walk, confirm, calendar, tonight

Default Ollama stack (each role can be overridden):

Gemma (gemma4:31b-cloud) — primary gather / care-profile draft
Qwen2.5 14B — second gather (different model family, same excerpts)
Llama 3.1 8B — judge merges the two JSON drafts

Plant-care refresh is deliberately three Ollama calls: research_a and research_b in parallel, then judge. Terminal tracing ([YardSloth LLM]) makes it obvious when the sloth is thinking vs. when Python is enforcing dates.

Model explains, code decides: frost thresholds (36° / 32° / 28° F), old-wood vs. new-wood prune windows, and calendar spacing are deterministic Python—not LLM guesses. That’s how you get trustable alerts without babysitting the model.

Why Does Open Innovation Matter?

Closed garden apps want your photos, your address, and a subscription. Yard Sloth flips that:

Open-weight models via Ollama — you can run offline-capable stacks, swap Gemma for Qwen, or point at a local runner without re-architecting the app.
Open agent patterns — LangGraph’s gather/judge graph is inspectable; you see two drafts and a merge, not one black-box completion.
No mandatory cloud brain — session state stays in memory on your machine; the sensitive part is “what’s in my yard,” not a vendor’s training set.
MCP instead of frozen JSON — care guidance is fetched from live sources when needed, so you’re not locked to a vendor’s stale plant database.

A closed API could summarize a blog post about hydrangeas. It couldn’t give me reproducible frost math, calendar exports I own, and two-model disagreement resolved by a judge—unless I paid forever and sent my yard data upstream. Open stacks made the lazy path local.

My Agent Session

This session is related to publishing the project to dev

Yard Sloth Week 3 — LangGraph judge pipeline

You

Save your agent session with DevRelay and embed it in your post, or link to it. It's optional, but it helps the judges understand your process.

How can I do that?

Agent

Explained DevRelay Agent Sessions: save via Cursor + DevRelay (submit_agent_session), optional CLI (devrelay sessions submit), embed on DEV with {% agent_session id_or_slug %} or message ranges/slices, or link to a published session. Noted MLH/DevRelay auth requirement and scrubbing secrets before upload.

You

Save this agent session to DEV as 'Yard Sloth Week 3 — LangGraph judge pipeline'

Agent

Prepared normalized transcript for DEV upload with title matching the Week 3 submission. Context: Yard Sloth uses LangGraph dual-gather + judge in agents/llm/graphs/dual_judge_graph.py (parallel gather_a/gather_b on Ollama, then judge merge).

▸ read_file agents/llm/graphs/dual_judge_graph.py

Input

agents/llm/graphs/dual_judge_graph.py

Output

LangGraph StateGraph: DualJudgeState with parallel _gather_a/_gather_b (chat_completion to model_a/model_b), warnings on single-gather failure, judge node merges candidates into final_text + judge_rationale.

The Lazy Payoff

Before Yard Sloth, my “system” was: random Notes app bullets, one panicked frost search per cold snap, and pruning guilt.

Now:

One yard walk seeds the season (≈15 minutes once).
Confirm screen is the only mandatory human gate for plant identity.
Calendar spreads chores so I’m not cramming dormant pruning into a single overwhelmed Saturday.
Tonight tells me if I need buckets and blankets before I’m in pajamas.

Conservative estimate: 2–3 hours/month of tab-hopping and calendar thrashing replaced by a Sunday glance and an occasional frost checklist. The sloth wins by doing less, more reliably.

Prize Categories

I'm entering:

Best Use of Gemma — primary gather model (gemma4:31b-cloud via Ollama) drafts structured plant-care JSON from web excerpts before the judge step.

I'm not claiming categories for tools I didn't integrate (MongoDB Atlas, Render, Sentry tracing, etc.).

Built for Hacktoberfest 2026 — Slow and Steady. Questions welcome in the comments.

Help My Garden

Luiza — Sat, 10 Oct 2026 04:26:27 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

It helps with your garden activities and chores. It tells you what can be planted, trimmed, propagated, fertilized, etc at the time of requesting the app.

Demo

https://drive.google.com/file/d/1nRWGDABsHYLXATUK4peXaxWRfYPF3pat/view?usp=sharing

Code

https://github.com/myluco/gardenHelp

How I Built It

This project was built using google ai studio. I gave several specific prompts how to build and which tech stack to use. When running locally, I chose the online Ollama model gemma4:31b-cloud. As the agent framework, I chose crew.ai for its simplicity.

Why Does Open Innovation Matter?

In this project, the open llm can save money, if it can be loaded in a machine. Furthermore, your data will keep private.
Regarding the agent framework, crew ai is so simple to use.

Prize Categories

Best use of Gemma