Forem: Daniel Jemiri

SQL-Speak: AI-Powered Natural Language Interface for Databases

Daniel Jemiri — Mon, 26 Jan 2026 12:00:37 +0000

This is a submission for the GitHub Copilot CLI Challenge

✨ Updates (Jan 27)

Benchmark Profile & Production-Ready Features Added!

Since the challenge submission, I've added several major features that take SQL-Speak from demo to production-ready:

🏁 PostgreSQL Benchmark Profile (--profile benchmark-postgres)
- Safe for analytics workloads: SELECT-only enforcement, auto-applies

🏗️ Project Architecture (NEW!)

SQL-Speak is a multi-component system with:

CLI Layer: Terminal-native interface using Typer
Core Engine: Database connection, schema detection, Copilot integration, query execution
REST API: Programmatic access with authentication & authorization
Web Dashboard: Modern Next.js interface for enterprise use
Data Generator: PostgreSQL benchmark data generation (10M+ rows)
Configuration: TOML-based environment management

💻 Development Setup

Prerequisites

Python 3.8+
Node.js 16+ (for web dashboard)
GitHub CLI with Copilot extension
PostgreSQL 12+ (optional, for benchmarks)

Quick Start

# Backend
git clone https://github.com/jemiridaniel/SQL-Speak.git
cd SQL-Speak
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Frontend
cd web
npm install
npm run dev

# CLI Usage
python3 main.py --db hospital.db "Show me all patients older than 30"

📦 Key Dependencies

typer[all]: CLI framework
sqlalchemy: Database toolkit
pexpect: GitHub Copilot CLI interaction
psycopg2-binary: PostgreSQL adapter
tabulate: Result formatting
Next.js: Web dashboard framework

🔒 Security & Environment Setup

Protected Environment Variables

A .env.example template is provided for safe setup:

cp .env.example .env
# Edit .env with your actual values (NOT committed to git)

All .env* files are gitignored to prevent credential leaks.

🚀 Deployment Ready

API Server: Gunicorn production deployment
Web Dashboard: Vercel-ready Next.js build
Database: PostgreSQL, SQLite, MySQL support
Benchmarking: Safe profile for 10M+ row datasets

🛠️ Contributing

Extend SQL-Speak by:

Adding database dialect support in core/db.py
Implementing features in appropriate modules
Documenting API changes
Testing with provided generator

📚 Core Modules

core/copilot.py: GitHub Copilot integration
core/engine.py: Query execution pipeline
core/db.py: Database operations & schema detection
core/profiles.py: Execution profiles (standard, benchmark)
api/: REST API with authentication
web/: Next.js enterprise dashboard

🎯 What's Next

[ ] Query caching & optimization
[ ] Advanced result visualization
[ ] Multi-database transactions
[ ] Query performance analytics
[ ] Community plugin system

GitHub: https://github.com/jemiridaniel/SQL-Speak

*Built with ❤️ for the GitHub Copilot CLI Challenge*LIMIT 100

Shows EXPLAIN ANALYZE before execution to catch performance issues
Real-world scenario: Query 10M+ row datasets safely from the terminal
- 📊 Built-in EXPLAIN ANALYZE Preview
Validates query performance before running (no more accidental full-table scans!)
Shows query plans to understand what's happening under the hood
- 🏗️ Data Generator for Benchmarking
Generates 10M+ row realistic datasets with python -m generator.cli
Tables: customers, products, orders, order_items, payments
Perfect for stress-testing analytics queries
- 🔄 Multi-Turn Refinement Mode
Ask follow-up questions to refine queries naturally
Example: "Show revenue by country" → "Only completed payments" → "Top 5 by revenue"

Check the updated GitHub repo for full details and the new README!

What I Built

SQL-Speak is a terminal-native utility that bridges the gap between natural language and structured data. It leverages the GitHub Copilot CLI as an intelligent translation layer, allowing developers to query local databases (like SQLite) using plain English. Instead of context-switching to a heavy GUI or manually writing complex JOINs for a quick data check, you can simply "speak" to your database directly from the command line.

Demo

Source Code: https://github.com/jemiridaniel/SQL-Speak
Video Walkthrough: https://monosnap.ai/file/qdcGJmiFRoaegroJOc19X7uxwcZivV

My Experience with GitHub Copilot CLI

Building SQL-Speak highlighted the "agentic" power of the Copilot CLI. By integrating the new gh copilot -p agentic prompt syntax into the application's backend, I was able to transform vague natural language intents into precise SQL queries.

The CLI's ability to understand context made it possible to pass database schema hints into the prompt, ensuring the generated SQL was not just syntactically correct, but also contextually aware of my specific table structures. It turned the terminal from a static environment into a conversational data assistant.

githubcopilot #copilotclichallenge #cli #python #ai

🏥 Medical Knowledge Assistant: AI-Powered Health Information with Algolia Agent Studio

Daniel Jemiri — Fri, 09 Jan 2026 13:55:37 +0000

This is a submission for the Algolia Agent Studio Challenge: Consumer-Facing Non-Conversational Experiences

I built a Medical Knowledge Assistant – an AI-powered conversational agent that helps users find accurate, evidence-based medical information about symptoms, treatments, tropical diseases, and preventive care. The assistant is specifically designed to serve communities in Sub-Saharan Africa, particularly Nigeria, where access to reliable health information is critical.

Key Features:

– 🔍 Instant Medical Information: Users can ask natural language questions about health conditions
– 🌍 Region-Specific Content: Focused on tropical diseases prevalent in Nigeria and Sub-Saharan Africa (malaria, yellow fever, typhoid, tuberculosis, Lassa fever)
– 🩺 Evidence-Based Responses: All information is sourced from a curated medical Q&A database
– ⚡ Fast Retrieval: Sub-second response times powered by Algolia's search infrastructure
– 💬 Conversational Interface: Clean, user-friendly chat UI built with React

Demo

Live Application

🔗 Live Demo ← Try it now!

📂 GitHub Repository

Try It Yourself

Ask questions like:
– "What are the symptoms of malaria?"
– "How is yellow fever prevented in Lagos?"
– "What antimalarial drugs work in Nigeria?"
– "How is tuberculosis diagnosed?"

Demo Screenshot

The interface showing a live query about malaria symptoms and the AI-generated response with medical information and appropriate disclaimers.

How I Used Algolia Agent Studio

Data Indexing

I indexed 113 medical Q&A records into Algolia's medical_knowledge index covering tropical diseases prevalent in Sub-Saharan Africa.

Data Structure:
– objectID: Unique identifier
– question: Patient question
– answer: Medical response
– category: Disease/topic classification (malaria, yellow fever, tuberculosis, etc.)

Agent Configuration

Created an AI agent (ID: 9abf468d-c860-4aba-baf0-de3cdabcaa76) with:
– LLM Integration: Google Gemini 1.5 Flash for natural language understanding
– Search Parameters: Optimized for medical terminology retrieval
– Response Template: Structured to provide clear medical information with appropriate disclaimers

Query Pipeline

User asks health question in natural language
Algolia Agent Studio processes query through semantic understanding
Searches indexed medical records using vector embeddings
LLM synthesizes relevant information into conversational response
Returns answer with educational disclaimer

React Integration

Built frontend using Algolia's Agent Studio React components:

import { AlgoliaAgentProvider, SearchBox, Messages } from '@algolia/agent-studio-react';

<AlgoliaAgentProvider
  appId="FS5S2685DH"
  apiKey={YOUR_API_KEY}
  agentId="9abf468d-c860-4aba-baf0-de3cdabcaa76"
>
  <SearchBox />
  <Messages />
</AlgoliaAgentProvider>

Why Fast Retrieval Matters

In healthcare contexts, speed directly impacts outcomes:

1. Emergency Decision Making

When someone experiences symptoms like high fever, severe headache, or difficulty breathing (common in malaria/typhoid), they need immediate information to decide whether to seek emergency care. Sub-second search responses enable faster decision-making.

2. Resource-Constrained Settings

In Sub-Saharan Africa:
– Many areas have limited internet connectivity (2G/3G networks)
– Mobile data is expensive
– Healthcare facilities may be hours away

Fast retrieval minimizes data usage and wait times, making the tool accessible even on slow networks.

3. Information Accuracy

Traditional web searches for medical questions often return:
– Unreliable sources
– US/Europe-focused information (not relevant to tropical diseases)
– Conflicting advice requiring extensive fact-checking

Algolia's fast, structured retrieval from curated medical records ensures users get accurate, region-specific information instantly without sifting through irrelevant results.

4. User Trust & Engagement

Healthcare information requires trust. When responses are:
– Instant (< 1 second)
– Relevant (specific to their region/disease)
– Consistent (always from vetted medical sources)

Users are more likely to rely on the tool for health decisions rather than potentially harmful misinformation.

5. Scalability

As the medical knowledge base grows (adding more diseases, treatments, regional variations), Algolia's infrastructure maintains fast retrieval without performance degradation. This is critical for expanding to serve millions of users across Africa.

Technical Stack

– Frontend: React + Vite
– AI Agent: Algolia Agent Studio
– LLM: Google Gemini 1.5 Flash
– Search Index: Algolia (113 medical records)
– Deployment: Netlify
– Data Source: Curated medical Q&A dataset

Impact & Future Plans

This assistant addresses the critical need for accessible medical information in Sub-Saharan Africa. Future enhancements:
– Expand dataset to 500+ medical Q&A covering more tropical diseases
– Add multi-language support (Yoruba, Igbo, Hausa, Swahili)
– Integrate with SMS/WhatsApp for offline access
– Partner with local healthcare organizations for content verification

⚕️ Educational Disclaimer: This tool provides general health information for educational purposes. Always consult a healthcare professional for personalized medical advice.

Setting Up NGINX on Ubuntu: My Experience As a Beginner in DevOps

Daniel Jemiri — Sun, 02 Feb 2025 14:32:59 +0000

Introduction

As part of the HNG DevOps internship, I was tasked with configuring an NGINX web server on a fresh Ubuntu instance. This challenge aimed to assess my ability to work with basic web server configurations and deliver a functional static website. In this blog post, I will walk through my approach, highlight challenges I faced, and reflect on the learning experience.

Task Breakdown

The assignment required me to:

Install and configure the NGINX web server.

Serve a custom HTML page with the message:

"Welcome to DevOps Stage 0 - Daniel Jemiri/Survey"

Ensure the page is accessible via a public IP address.

Document the process and reflect on the experience.

Step 1: Setting Up the Ubuntu Server

I opted to use an Ubuntu 22.04 server on Google Cloud. The steps included:

Creating a Compute Engine instance and assigning a public IP.

Configuring firewall rules to allow traffic on port 80 (HTTP).

Connecting to the instance via SSH:

gcloud compute ssh --zone=<your-zone> <your-instance-name>

Step 2: Installing and Configuring NGINX

Installing NGINX

First, I updated the system and installed NGINX:

sudo apt update && sudo apt install -y nginx

To verify the installation:

nginx -v

I enable and check the status of the nginx
Enable NGINX to Start on Boot:

sudo systemctl enable nginx

Check NGINX Status:

sudo systemctl status nginx

You should see active (running) in the output.

Configuring the Web Server

To customize the default page, I modified the index.html file:

sudo nano /var/www/html/index.html

And added the required content:

<!DOCTYPE html>
<html>
<head>
    <title>DevOps Stage 0</title>
</head>
<body>
    <h1>Welcome to DevOps Stage 0 - Daniel Jemiri/Survey</h1>
</body>
</html>

Save and Exit:

:wq

After saving the file, I restarted NGINX to apply the changes:

sudo systemctl restart nginx

Step 3: Testing the Deployment

To confirm everything worked, I accessed my server’s public IP in a browser:

[YOUR_SERVER_IP](http://YOUR_SERVER_IP)

The page loaded successfully, displaying the custom message.

To ensure NGINX was running properly, I used:

sudo systemctl status nginx

Everything was set up correctly without errors.

Challenges and Solutions

Firewall Issues:

Initially, I couldn’t access the page from my browser.

Solution: I checked firewall rules and allowed HTTP traffic using:

gcloud compute firewall-rules create allow-http --allow tcp:80

File Permission Errors:

I encountered a permission error while editing index.html.

Solution: Used sudo to grant appropriate permissions:

sudo chmod 644 /var/www/html/index.html

Lessons Learned

This task provided hands-on experience with:

Installing and configuring NGINX.

Managing an Ubuntu server via SSH.

Debugging firewall and permission issues.

Deploying a static web page on a cloud server.

Understanding these core DevOps concepts is crucial as they align with roles like Site Reliability Engineers and Cloud Engineers.

Conclusion

Completing this task enhanced my ability to work with web servers and troubleshoot deployment issues. It reinforced my understanding of infrastructure setup, which is essential for any DevOps engineer. I look forward to tackling more complex challenges in the upcoming stages!

References and Further Reading

As I continue my journey, I’m inspired by the opportunities available at HNG Tech. Here are some roles that align with these aspirations and may inspire you too:

DevOps Engineers
Cloud Engineers
Site Reliability Engineers
Kubernetes Specialists
AWS Solutions Architects
Azure DevOps Engineers
Google Cloud Engineers