An alternative to PG-Admin with LLM

Muhammad Waleed — Sat, 11 Apr 2026 15:24:13 +0000

Stop Writing SQL Just to Check Your Own Database

There's a moment every backend developer knows.

You're deep in the zone, building a feature, and suddenly you need to quickly check something in the database. How many users signed up today? Are there any orders stuck in a pending state? What's the latest entry in that table?

So you stop. You open pgAdmin, wait for it to load, navigate to the right database, open the query tool, write the SQL, run it, check the result, and then try to remember where you were.

That's five minutes gone. And it happens ten times a day.

I got tired of it, so I built something to fix it.

What is DB LLM Console?

DB LLM Console is a self-hosted Docker image that gives you a clean chat UI to query your PostgreSQL database in plain English. You drop it into your existing docker-compose.yml, give it your DB credentials and an OpenAI API key, and you get a lightweight interface that sits right next to your stack.

Think of it as a simpler, friendlier alternative to pgAdmin — but instead of writing SQL, you just ask questions.

Instead of:

SELECT * FROM orders
WHERE created_at >= NOW() - INTERVAL '7 days'
AND status = 'pending';

You type:

"Show me pending orders from the last 7 days"

That's it. It figures out the SQL, runs it against your DB, and shows you the results.

Why Not Just Use pgAdmin?

pgAdmin is a powerful tool and it absolutely has its place. But for day-to-day development work, it feels like overkill. It's a full DB management suite — connection managers, schema browsers, ERD tools, backup utilities. That's a lot of surface area when all you want is a quick answer.

DB LLM Console doesn't try to replace pgAdmin for everything. It just handles the most common thing developers actually do: query data and look at results.

Setting It Up

Setup is straightforward. Add this to your existing docker-compose.yml:

db-llm-console:
  image: devleed/db-llm-console:latest
  container_name: db-llm-console-dev
  restart: unless-stopped
  depends_on:
    postgres:
      condition: service_healthy
  environment:
    DATABASE_HOST: ${DATABASE_HOST:-postgres}
    DATABASE_PORT: ${DATABASE_PORT:-5432}
    DATABASE_NAME: ${DATABASE_NAME:-postgres}
    OPENAI_API_KEY: ${OPENAI_API_KEY}
  ports:
    - '127.0.0.1:4000:4000'
  networks:
    - your-network-name

Then add your values to your .env file:

DATABASE_HOST=your-db-host
DATABASE_PORT=5432
DATABASE_NAME=your-database-name
OPENAI_API_KEY=sk-...

Run docker compose up and open http://localhost:4000. That's your setup done.

No extra config files, no new services to maintain, no installation steps beyond what you already do for Docker.

How It Works

Under the hood it's a Node.js/Express backend that takes your plain English question, sends it to the OpenAI API along with your database schema, gets back a SQL query, runs it against your PostgreSQL database, and returns the results to the React frontend.

No frameworks like LangChain. Just a direct call to the OpenAI API, keeping the setup lean and the behavior predictable.

The backend and frontend are bundled together in a single image, so there's only one service to manage. Everything runs on port 4000.

A Use Case I Didn't Expect

Here's something that became obvious pretty quickly after building this: it's not just useful for developers.

Think about the non-technical people on your team or around your project. PMs who want to check product metrics. Clients who want to see their own data without raising a ticket. Stakeholders who ask "how many X do we have this month?" every single week.

Right now, every one of those questions lands on a developer. Someone has to write the query, pull the data, format it, and send it back. It's a small thing but it adds up.

With DB LLM Console, you can give those people direct access. They open the chat, type their question in plain English, and get the answer themselves. No SQL knowledge needed. No developer in the loop for routine data questions.

That change alone frees up a surprising amount of developer time.

Security Considerations

This tool has direct access to your database, so it should be treated accordingly.

A few things to keep in mind:

Bind the port to 127.0.0.1 as shown in the docker-compose example above so it is only accessible from your own machine
Use a read-only database user if you only need to query data and don't want write access exposed
Never expose this service publicly without authentication
Never commit your .env file with real credentials to version control

Token-based authentication is on the roadmap. For now, treat it as an internal dev tool.

Who Is This For?

DB LLM Console is a good fit if you are:

A backend developer who wants faster access to their data without context switching
A team that wants to give non-technical members a way to query data themselves
Someone building a product for clients who need visibility into their own data
Anyone who finds pgAdmin too heavy for everyday use

It is available on Docker Hub right now. Pull it, drop it into your stack, and try it out.

docker pull devleed/db-llm-console:latest

Docker Hub: https://hub.docker.com/r/devleed/db-llm-console

If you give it a try, I'd genuinely love to hear what you think. What works, what doesn't, what you'd want added. Drop a comment below.

DEV Community: Muhammad Waleed