DEV Community: TJ

Run Claude for FREE Locally (Using Ollama + Claude Code)

TJ — Wed, 25 Feb 2026 16:58:14 +0000

Want to use a Claude-like coding assistant without paying API costs?

In this guide, I’ll show you how to run it (step-by-step) locally using Ollama and Claude Code.

🧠 What You’ll Build

Local LLM setup (no API cost)
Claude-style coding assistant
Fully offline workflow (optional)

⚙️ Step-by-Step Setup

1. Install Ollama

Ollama is the engine that runs LLMs locally.

curl -fsSL https://ollama.com/install.sh | sh

Verify:

ollama -v

2. Install Claude CLI

Follow:
https://code.claude.com/docs/en/quickstart

If you see claude is not installed, you missed this step.

3. Install Claude Code

npm install -g @anthropic-ai/claude-code

4. Pull a Coding Model

Command :

ollama pull qwen2.5-coder:7b

You will see :

5. Configure Environment

Add to your ~/.bashrc or ~/.zshrc:

export PATH="$HOME/.local/bin:$PATH"
export ANTHROPIC_BASE_URL=http://localhost:11434/v1

Reload:

source ~/.bashrc

You will see :

6. Launch Claude

ollama launch claude

Now Claude will use your local Ollama model.

Free Claude Ready to Use

During my exploration, I got my model was confuse and the answer was not my want.

🔄 Try Alternative Models

ollama pull glm-5:cloud

Then:

ollama launch claude

Choose the new model. The New Model was more precise and answer the question well.

💻 Example Prompts

Based on the current project purpose that for explain about claude playground, I want you to trigger technical architect skill here to create boiler plate for golang, to create simple, concise and easy to learn. Please also put the README file about this project. Before you write and work for it, I want you to create a terminal wireframe to show me exactly, using the ASCII art, where you can be able to create a terminal wireframe of exactly what it is going to look like for this playground before we do implementation.

If you want to know about the history of the conversation and the project that created by Free Claude, you can the github below

Modernizing Cephalometric Analysis: Building a Web App for Orthodontic Diagnostics

TJ — Mon, 01 Dec 2025 17:56:04 +0000

The Problem: When Legacy Code Meets Modern Needs

The original cephalometric analysis tool worked, but it was slow. 30+ second build times, sluggish UI, and technology from 2018. As a developer working in healthcare technology, I modernized this legacy application - and the results were dramatic.

The results: 30+ second builds → <1 second HMR, 100% class components → modern React hooks, and 100% backward compatibility maintained. The result is Ortho Cephalometry.

What is Cephalometric Analysis?

Cephalometric analysis is the science of measuring facial structures - how teeth, jaws, and facial bones relate to each other. Orthodontists use lateral cephalogram X-rays to:

Measure angles and distances between anatomical landmarks
Assess skeletal and dental relationships
Plan treatment (braces, aligners, surgery)
Track progress over time

The analysis involves placing specific points on X-ray images and calculating measurements using methods like Downs Analysis, Steiner Analysis, Tweed's Triangle, and more. Accuracy and speed matter - these measurements directly impact treatment decisions.

The Modernization Journey

Before → After

Original Stack (from 2018):

Webpack 4 (30+ second builds)
React 16 (class components)
TypeScript 2.9
TSLint (deprecated)
node-sass
MobX 5

Modern Stack:

Vite 5 - <1 second HMR
React 18 - Functional components with hooks
TypeScript 5 - Better type inference
ESLint - Modern linting
Sass (Dart Sass) - Latest compiler
MobX 6 - Latest state management

Key Improvements

Build Times: 30+ seconds → <1 second for HMR
Component Architecture: 100% migration to functional components with hooks
Type Safety: TypeScript 5 caught several bugs during migration
Developer Experience: Comprehensive Makefile for easy project management

The Challenge: 100% Backward Compatibility

We maintained complete compatibility - same file format, same iframe protocol, identical analysis results. Users can migrate without losing any data. Zero breaking changes.

Features

Interactive Point Placement: Upload X-rays and place anatomical points with drag-and-drop
9+ Analysis Methods: Downs, Steiner, Tweed, Wits, and more
Save & Load: .cephalometric format for tracking patients over time
Export: PNG export for patient reports
Embeddable: iframe support for integration into larger systems

Technical Highlights

MobX 6 for reactive state management - when points are placed, calculations update automatically:

import { observer } from 'mobx-react-lite';

export const Main = observer(() => {
  // Automatically re-renders when observable data changes
  return <AnalysisView />;
});

Modern React Hooks - clean, testable code:

useEffect(() => {
  window.onmessage = function (e) {
    if (e.data?.startsWith('cephalometric-open:')) {
      data.loadProject(parseProjectData(e.data));
    }
  };
}, []);

TypeScript 5 caught several undefined point errors during migration that would have been runtime bugs.

Getting Started

Prerequisites

Node.js 18+ and npm
Make (usually pre-installed on Unix-like systems)

Quick Start

# Clone and install
git clone https://github.com/tjandrayana/ortho-cephalometry.git
cd ortho-cephalometry
make install

# Run dev server (background)
make dev-bg

# Check status, view logs, or stop
make status
make logs
make stop

The app runs at http://localhost:3000 with instant HMR thanks to Vite.

Key Makefile Commands: make install, make dev-bg, make build, make preview, make lint, make clean

Alternative: Use npm scripts directly (npm install, npm run dev, etc.)

Project Structure

ortho-cephalometry/
├── src/
│   ├── data/              # MobX state management
│   ├── literature/         # Cephalometric definitions
│   │   ├── analysis/      # Analysis methods
│   │   ├── angles.ts      # Angle definitions
│   │   ├── distances.ts   # Distance measurements
│   │   └── points.ts      # Point definitions
│   ├── view-components/   # React components
│   └── main.tsx           # Entry point
├── Makefile               # Build automation
└── vite.config.ts         # Vite config

Migration Notes

100% backward compatible - existing .cephalometric files work perfectly. Same file format, same iframe protocol, identical analysis results. Users can migrate seamlessly.

Use Cases

Orthodontic Clinics: Daily diagnostic analysis
Dental Schools: Educational tool for teaching
Research: Data collection and analysis
Practice Management: iframe integration into larger systems

Lessons Learned

What worked: Vite over Webpack (build time improvement was huge), sticking with MobX (perfect for reactive calculations), the Makefile (small QoL improvements matter), 100% backward compatibility (zero migration pain).

What I'd do differently: Start with TypeScript 5 directly (incremental upgrade was slower), convert components in batches (more efficient), add more tests before migration (would catch issues earlier).

Conclusion

Modernizing this application created a tool that saves time, reduces errors, improves maintainability, and enhances developer experience. The result serves the orthodontic community while being a pleasure to develop with.

If you're working in healthcare technology or modernizing legacy applications, I hope this project serves as a useful reference. The techniques apply to any legacy React application.

Check it out: Repository | Original Project | Original Demo

Note: This tool is intended for professional use by qualified dental professionals. Always ensure proper training and understanding of cephalometric analysis before using in clinical practice.

A beginner's journey from setup hell to jump to heaven: Building a tool that does it in 30 seconds

TJ — Tue, 18 Nov 2025 16:42:59 +0000

🎼 Building Stack Orchestra: From "I Can't Code" to "I Built This"

Ever spent 3 hours setting up a database just to test a 5-minute feature?

Yeah, me too. That's why I built Stack Orchestra.

🎬 The Moment Everything Changed

Picture this: It's 2 AM. You're learning to code. You need PostgreSQL for your project. You Google "how to install PostgreSQL," follow 15 different tutorials, mess up your system, spend hours fixing it, and finally—FINALLY—get it working.

Then you realize you also need Redis. And Elasticsearch. And maybe Neo4j.

Sound familiar?

I just started learning to code, and I was drowning in setup hell. Every time I wanted to try a new technology, I'd spend more time configuring it than actually learning it. That's when I had my "enough is enough" moment.

What if there was a way to spin up any tech stack with one command?

That question led me to build Stack Orchestra—and it changed everything.

😤 The Problem That Drove Me Crazy

Let me paint you a picture of my life before Stack Orchestra:

The Old Way (The Painful Way) 😰

Monday: "I need PostgreSQL"
  → 2 hours installing PostgreSQL
  → 1 hour configuring it
  → 30 minutes troubleshooting
  → Finally working! ✅

Tuesday: "Now I need Redis"
  → 1 hour installing Redis
  → 30 minutes configuring
  → Conflict with PostgreSQL port
  → Fix conflict, restart everything
  → Finally working! ✅

Wednesday: "Let me try Elasticsearch"
  → 3 hours of Docker Compose hell
  → Memory issues
  → Port conflicts
  → Give up, use cloud version 😢

Total time wasted: 8+ hours

Actual coding time: Maybe 2 hours

The New Way (The Stack Orchestra Way) 🚀

# Need PostgreSQL? 
make postgres-up
# Done in 30 seconds ✅

# Need Redis too?
make redis-up  
# Done in 30 seconds ✅

# Want Elasticsearch + Kibana?
make kibana-up
# Automatically starts Elasticsearch too!
# Done in 1 minute ✅

Total time: 2 minutes

Actual coding time: The rest of your day!

💡 The "Aha!" Moment

I was sitting there, frustrated, thinking: "Why does this have to be so hard?"

Then it hit me: What if each technology was a separate, independent service? What if I could start just what I need, when I need it?

That's when Stack Orchestra was born.

🎯 What Stack Orchestra Actually Does

Think of Stack Orchestra as your personal tech stack butler. You tell it what you need, and it handles the rest.

🎪 Try This Right Now (Seriously, Do It!)

Open your terminal and run:

git clone https://github.com/tjandrayana/stack-orchestra
cd stack-orchestra
make help

Boom! You just saw all 9 available services. That took 10 seconds.

Now try this:

make postgres-up

Wait 30 seconds...

make ps

Look at that! PostgreSQL is running. No configuration. No headaches. Just... working.

That feeling? That's what I wanted to give to every developer.

🎨 The Magic: How It Actually Works

1. 🎯 Run Only What You Need

Before Stack Orchestra:

# Start entire docker-compose with 9 services
docker-compose up -d
# Your laptop: 💻🔥🔥🔥 (overheating)
# Your RAM: 📈📈📈 (maxed out)
# Your sanity: 😵 (gone)

With Stack Orchestra:

# Just need PostgreSQL? 
make postgres-up
# Only PostgreSQL runs. Your laptop: 😌 (happy)

Real talk: How many times have you started a full docker-compose just to use one service? Stack Orchestra fixes that.

2. 🧠 Smart Dependency Management (It's Actually Smart!)

Here's where it gets cool. Watch this:

make kibana-up

What just happened?

Stack Orchestra saw you want Kibana
It checked: "Does Kibana need anything? Yes, Elasticsearch!"
It started Elasticsearch first
Then it started Kibana
You did nothing. Just one command.

Try it yourself:

make kibana-up
make ps
# See both Elasticsearch AND Kibana running? 
# That's the magic! ✨

The best part? You don't need to remember dependencies. Stack Orchestra does.

3. ⚡ Choose Your Speed

Feeling patient? Start services one by one:

make up
# Services start sequentially, nice and calm

Feeling impatient? Start them all at once:

make up-parallel
# Everything starts simultaneously
# Your laptop: "Challenge accepted!" 💪

Want to control the chaos?

PARALLELISM=3 make up-parallel
# Start 3 services at a time
# Perfect balance of speed and sanity

🎁 What's in the Box? (Spoiler: It's Awesome)

Stack Orchestra comes with 9 battle-tested technology stacks:

🎯 Technology	💡 What It's For	🚀 Try It
Elasticsearch + Kibana	Search & Analytics	`make kibana-up`
Neo4j	Graph Databases	`make neo4j-up`
PostgreSQL	Relational DB	`make postgres-up`
MySQL	Relational DB	`make mysql-up`
ArangoDB	Multi-model DB	`make arangodb-up`
Redis	Caching & Queues	`make redis-up`
MongoDB	Document DB	`make mongodb-up`
Nginx	Web Server	`make nginx-up`
OpenResty	Nginx + Lua	`make openresty-up`

Each one:

✅ Pre-configured (no setup needed)
✅ Health-checked (knows when it's ready)
✅ Isolated (won't conflict with others)
✅ Persistent (your data survives restarts)

🎬 A Day in My Life (With Stack Orchestra)

Let me show you how I actually use this:

🌅 Morning: Learning Graph Databases

make neo4j-up
# Opens Neo4j Browser at http://localhost:7474
# Learning Cypher queries
# Building my first graph

Time spent: 30 seconds to start

Time learning: The rest of the morning! 🎓

🌞 Afternoon: Building a REST API

make elasticsearch-up
make postgres-up  
make nginx-up
# Full stack running in 2 minutes
# Now I'm coding, not configuring!

Time spent: 2 minutes

Time coding: The rest of the afternoon! 💻

🌙 Evening: Experimenting with Lua

make openresty-up
# Testing Lua scripts at http://localhost:8081
# Building custom endpoints
# Having fun! 🎉

Time spent: 30 seconds

Time experimenting: All evening! 🚀

😴 Bedtime: Clean Shutdown

make down
# Everything stops cleanly
# No orphaned processes
# Good night! 😴

Time spent: 5 seconds

Peace of mind: Priceless ✨

🎓 What I Learned (And You Can Too!)

Building Stack Orchestra wasn't just about solving my problem—it was a crash course in:

1. 🐳 Docker Compose Architecture

I learned how to structure multi-file compose projects. Each service is independent, but they share a network. It's like having separate apartments in the same building.

2. 📝 Makefile Mastery

Makefiles aren't just for compiling C code! I learned to create reusable, parameterized build systems. It's like having a personal assistant that remembers all your commands.

3. 🎼 Service Orchestration

Managing dependencies and startup order taught me how real orchestration tools work. It's the same concepts used in Kubernetes, just simpler.

4. 👥 Developer Experience

The best tool is the one you actually use. I focused on making Stack Orchestra so simple that using it is faster than not using it.

🎯 Try It Yourself (No, Really!)

Right now, in the next 2 minutes:

Clone the repo:

   git clone https://github.com/tjandrayana/stack-orchestra
   cd stack-orchestra

See what's available:

   make help

Start your first service:

   make redis-up

Check it's running:

   make ps

Test it:

   redis-cli ping
   # Should return: PONG

Congratulations! You just started a service in under 2 minutes. No configuration. No headaches. Just... working.

That's the power of Stack Orchestra.

📊 The Impact: Before vs. After

Before Stack Orchestra:

⏰ Setup time: 2-3 hours per new technology
😰 Frustration level: High
💻 Actual coding: 20% of time
😵 Mental state: Exhausted

After Stack Orchestra:

⏰ Setup time: 30 seconds
😌 Frustration level: Low
💻 Actual coding: 90% of time
🚀 Mental state: Energized

The math is simple: More time coding = More learning = Better developer

🎁 Real-World Scenarios

Scenario 1: "I Need to Test Something Quickly"

Old way:

Install service (30 min)
Configure it (20 min)
Test (5 min)
Clean up (10 min)
Total: 65 minutes

Stack Orchestra way:

make <service>-up    # 30 seconds
# Test your thing
make <service>-down  # 5 seconds

Total: 35 seconds

You just saved 64 minutes. That's a whole episode of your favorite show!

Scenario 2: "I'm Building a Full-Stack App"

Old way:

Set up PostgreSQL (1 hour)
Set up Redis (30 min)
Set up Elasticsearch (1 hour)
Configure Nginx (30 min)
Fix conflicts (1 hour)
Total: 4 hours of setup

Stack Orchestra way:

SERVICES="postgres redis elasticsearch nginx" make up-parallel
# Wait 2 minutes...
# Start coding!

Total: 2 minutes

You just saved 3 hours and 58 minutes. That's enough time to build a feature!

🚀 What's Next? (The Roadmap)

I'm not done yet! Here's what's coming:

🔮 More Services: Kafka, Cassandra, InfluxDB, and more
📚 Better Docs: More examples, tutorials, and use cases
🎨 UI Dashboard: A web interface to manage services (maybe?)
🤖 Auto-Discovery: Automatically detect what services your project needs
🌍 Cloud Support: Deploy to AWS, GCP, Azure with one command

Want to help? Contributions are welcome! Check out the README for how to add new services.

💭 The Real Talk Section

Here's the truth: I'm still learning to code.

This project isn't perfect. There are probably better ways to do things. But you know what? It works. It solves a real problem. And it's mine.

That's the point.

You don't need to be a senior engineer to build useful tools. You just need to:

Have a problem
Build a solution
Share it with others

Stack Orchestra proves that even beginners can create something valuable.

🎯 Your Turn: What Will You Build?

Now that you know about Stack Orchestra, here's my challenge to you:

Try it: Clone the repo and start a service
Use it: Build something with it
Improve it: Found a bug? Want a feature? Contribute!
Share it: Tell someone who might find it useful

The best way to learn is by doing. Stack Orchestra gives you the infrastructure. Now go build something amazing!

🎬 The Conclusion (But Not Really)

Stack Orchestra started as a personal learning tool. Now it's something I'm proud to share.

But here's the real story: This isn't about Stack Orchestra. It's about you.

You're learning to code. You're facing the same problems I faced. You're spending hours on setup instead of coding.

You don't have to.

Stack Orchestra is here. It's free. It's open source. It's yours.

Use it. Improve it. Make it better. Share it.

Because the best tools aren't built by experts. They're built by people who have problems and decide to solve them.

🔗 Quick Links

🔗 Repository: github.com/tjandrayana/stack-orchestra
📄 License: MIT (use it however you want!)
🤝 Contributing: Pull requests welcome!
🐛 Issues: Found a bug? Let me know!
💡 Ideas: Have a feature request? Open an issue!

💬 Let's Connect!

Tried Stack Orchestra? Loved it? Hated it? Found a bug? Want to contribute?

I'd love to hear from you!

⭐ Star the repo if you find it useful
🐛 Open an issue if you find a problem
💡 Suggest features you'd like to see
🤝 Submit a PR if you want to help

Remember: We're all learning. Let's learn together.

Built with ❤️ by someone who's still learning, for others who are learning too.

Now go build something amazing! 🚀

🎁 Bonus: Quick Start Cheat Sheet

Save this for later:

# See all services
make help

# Start one service
make <service>-up

# Start multiple services
SERVICES="postgres redis" make up

# Start in parallel
SERVICES="postgres redis mongodb" make up-parallel

# Check status
make ps

# View logs
SERVICES="postgres" make logs

# Stop a service
make <service>-down

# Stop everything
make down

# Nuclear option (removes everything including data)
make clean

That's it. That's all you need to know.

Now go code! 💻✨