After decades of managing software programs across different industries, I still found myself spending hours each week writing JQL to get my reporting ready. Every project management tool I have worked with is excellent at storing data and painful at visualizing it. Jira is the best of them. It is still painful. The more you start exploring, the more knowledge and skills one needs to adapt to get a valuable result out of it. And even when you got the data, you still had to turn it into something a stakeholder could read, the right chart, in the right format, without a tutorial. Different reports for different audiences with variety of charts, everyone needed a different view of the same data.

Should I export the data to excel create a pivot table and then generate the chart, or should I use the dashboard reports manually creating each types of charts and linking with the right table, or should I use another custom tool provided by a third party vendor, choices are many but integration efforts and future reliability would be a question and pain. Another daunting topic would be to know how to query using various kinds of query language JQL, SQL or mdx or so on.

To overcome all these problems, I turned to AI, offloading all heavy lifting onto AI and focused on letting it generate the charts or tables with the right query. This is what the AtlasMind tool does, give a question in plain English about your project and you get charts rendered with tables that can be easily filtered and used for your reports with just a click of a button.

AtlasMind is live at atlasmind.de. It runs live against the public Apache jira server. Here is what it looks like in practice.

User : show me all open bugs in project Kafka ordered by priority

JQL    : project = KAFKA AND issuetype = Bug 
         AND status not in ('Closed', 'Resolved') 
         ORDER BY priority DESC

Ai Answer : Open bugs in Kafka project ordered by priority.
         Found 2170 result(s); showing 1000.

Live: https://atlasmind.de
Frontend: https://github.com/sunishbharat/AtlasMind-frontendUI
Backend: https://github.com/sunishbharat/atlasMind-Lite

Type a question in plain English. Get JQL, a chart and an answer in seconds.

Architecture

Query router: It classifies the user query into 3 paths, general pipeline, JQL pipeline or direct chart rendering.

RAG pipeline: when a query is classified as JQL, it follows the RAG pipeline. The system uses Sentence Transformers and pgvector libraries to store the JQL annotations, jira fields, associated values as embeddings. At query time, the user’s question is embedded and compared against stored vector embeddings. Pulls top 5 nearest neighbors using L2 distance between the query and the jira fields available.

LLM Orchestrator: This layer acts as the backend switch to an active backend of the systems choice like Groq, ollama, claude etc. Each backend is a separate async client module.

Self-correcting JQL loop: Before the LLM generated JQL reaches the Jira API, it goes through a 7-pass sanitizer. These seven passes manage the most common LLM failure modes without any LLM call which makes the system more robust. After sanitization, the JQL is regenerated by LLM and is executed against the Jira REST API. This is where the agentic feedback loop begins. The loop runs up to n number of retries. When Jira identifies a specific invalid field by name, the prompt tells the LLM to remove that exact field condition and not to guess or hallucinate any fields. This surgical assertion makes the LLM generate a very deterministic JQL which is valid.

Multi-backend architecture: Why I decided on multi backend is for easy design and usage. During my initial development phase, I built the initial version using local LLM model Ollama with zero cost, zero API tokens, zero cloud dependency. Later I extended it to support other limited/free models which was much better in performance and JQL generation quality.

Deployment: AtlasMind runs on Oracle cloud Infrastructure A1 instance with PostgreSQL + pgvector, Groq (default), Ollama (fallback), and the frontend. This instance hosts everything FASTAPI backend, postgresSQL, Ollama as the local inference fallback and the Svelte frontend. For better performance and heavier inference, there is also support to run on local GPU system running vLLM with quantized 7B Qwen2.5-Coder model over HTTP. When GPU system is off, AtlasMind falls back to local Ollama automatically with no configuration change or restart required.

What I Learned

• I have not load tested AtlasMind under concurrent users at scale. Likely bottlenecks are pgvector query time under high vector search volumes. Jira API rate limits under parallel requests and LLM inference latency under load. These are unknown problems and honestly for a side project built during evenings and weekends, discovering these problems is a real challenge.

• One important distinction is that the LLM model is still not fully capable of generating a JQL on its own, multiple trial and errors with surgical assertions still do not make it fully dependable. Fine-tuning with the specific Jira instances would get the JQL generation accuracy significantly higher.

• Implemented entirely raw without using Langchain or Langgraph libraries, I deliberately built the RAG pipeline and agentic loop from scratch to understand what was happening under the hood. I am equally interested to see if the result changes when used with standard libraries.

AtlasMind is what I wish existed across every programme I have ever run. I built it to prove that the gap between Engineering execution and project intelligence can be closed.

Live: https://atlasmind.de
Frontend: https://github.com/sunishbharat/AtlasMind-frontendUI
Backend: https://github.com/sunishbharat/atlasMind-Lite