DEV Community: HK Verma

Reasoning Email Access Logs with LitenAI

HK Verma — Thu, 12 Jun 2025 00:02:20 +0000

Traditional log analytics tools fall short when diagnosing complex, cross-system issues due to limited context and lack of reasoning. LitenAI addresses these limitations with AI agents that reason, correlate, and explore operational data through a natural interface.

LitenAI agents analyze application logs, uncover key failure patterns, and recommend effective mitigation. By combining log data with domain knowledge, LitenAI enables proactive, insight-driven debugging at scale.

Why Traditional Log Analytics Tools Fall Short

Conventional log analytics tools require users to know what to look for and how to ask for it. They rely on predefined dashboards, rigid filter rules, and manual queries—often in proprietary or complex query languages. Users must understand how different logs relate across systems and services, and even then, meaningful insights often require escalation to domain experts for deeper root cause analysis.

These tools struggle when diagnosing complex, cross-system issues:

Conventional log analytics tools require users to know what to look for and how to ask for it. They depend on predefined dashboards, rigid filter rules, and manual queries—often in proprietary or complex query languages. Users must understand how different logs relate across systems and services, and even then, meaningful insights often require escalation to domain experts for deeper root cause analysis. These tools fall short when diagnosing complex, cross-system issues.

Contextual Blindness: They don’t connect logs to broader operational data like source code, past tickets, engineering knowledge, or documentation.
Limited Reasoning: They aggregate and visualize—but cannot explain why a problem is happening or how to fix it.
Manual Overhead: Analysts must piece together evidence across tools, often writing complex queries or scripts.

While AI tools have become powerful enough to automate some of this manual engineering work, traditional AI tools still fall short. Generic AI tools offer broad, detached explanations that lack grounding in real customer environments—often resulting in vague or misleading answers.

How LitenAI Breaks Through These Barriers

At LitenAI, we’ve developed customized AI models and agents specifically for log analytics. These agents work directly on application log data to automate analysis, reasoning, and resolution—efficiently and at scale.

Customers ingest logs, tickets, metrics, documentation, and metadata into a secure AI database. From there, the LitenAI Agentic AI platform initiates multi-step reasoning flows that:

Generate precise SQL queries based on user intent and schema
Correlate data across different sources
Deliver root cause insights, not just metrics
Recommend mitigation backed by prior resolutions and real-time evidence

Instead of searching dashboards or wrestling with log syntax, teams engage through conversation. LitenAI reasons, investigates, and explains—adapting to each environment with every prompt. This conversational interface and deep contextual awareness enable LitenAI to deliver precise, targeted answers tailored to each customer’s operational context.

LitenAI Database and Agents

LitenAI provides an AI-powered database designed to store logs, metrics, and documents at petabyte scale. Built on a lake house architecture using object storage, it offers dramatically lower ingestion and storage costs compared to traditional log systems. LitenAI integrates seamlessly with existing data sources through streams or database connections.

Users can create and ingest data into these databases programmatically or via a graphical interface. AI databases and agents can be selected through the UI or code, and the agents —available as MCP Servers— can also operate within an AI agentic web.

For the analysis below, select the AI database named emailaccess, which includes two ingested logs:

webmail: captures webmail UI requests
mailbox: records mailbox-level operations

In the UI side bar, see below and ensure that the right database and agents are selected for the tutorials shown below.

Root Cause Analysis in Email Access Logs

A customer had been experiencing frequent issues where users were unable to access their mailbox. As discussed earlier, the underlying system includes two primary logs – webmail and mailbox

Traditional log tools couldn’t connect the dots between these layers or explain why mailbox access was failing. With LitenAI, the customer was able to:

Prompt LitenAI to investigate why mailbox access errors were occurring so often.
Receive not just raw query results, but a structured root cause analysis and recommended mitigation, backed by log evidence.

Root Cause Agent: A single agent to root cause and mitigation

Choose the rootcause Agent from the AI agent list and prompt it to root cause.

Users are frequently unable to access their mailboxes. The webmail table contains webmail request logs, and the mailbox table contains mailbox operation logs. joined by requestid field. Investigate and identify the root cause by analyzing failed access patterns, status codes, and latency across both tables. Provide a clear explanation and recommended resolution based on the findings.

LitenAI starts by asking follow-up questions to clarify your prompt.

Once the prompt is clarified, LitenAI initiates the root cause analysis. Its reasoning models evaluate the context and the system calls involved. Based on this, it dynamically selects the appropriate tools—such as reasoning, search, and analysis agents—to identify and mitigate the issue.

In this case, the agent begins by creating a plan. It retrieves the relevant log data and analyzes it to determine the most probable cause.

It then retrieves customer knowledge using the RAG agent and continues deeper analysis. This process iterates until enough data is gathered to identify a probable cause.

The most likely causes are then synthesized, and a list of possible root causes is generated.

Using all available data, LitenAI determines the most probable cause and suggests appropriate mitigation.

Reason and Explorer Agents: Drill down using natural chats

You can search, analyze, visualize using natural chats. We are showing a few prompt playbooks that the user can use to investigate.

LitenAI Prompt Playbook: Investigating Email Access Issues

Before using these prompts, ensure the emailaccess database is selected, and your webmail and mailbox tables are available in the lake. Make sure that reason is selected as Liten AI Agent.

🔍 Analyze mailbox 5xx Errors

Investigate 5xx status code errors in the mailbox table using reason agent. Identify the most frequent failure scenario and explain the likely cause. Provide a resolution based on historical patterns.

✅ Use this when: Customers report frequent mailbox failures or timeouts.

In its reasoning, it first makes a plan.

It then executes the query and gets the data.

It then analyzes the produces the likely issues.

🧠 Debug Latency In webmail service

Reason out the high-latency cases from mailbox table. Pick top 100 worst latency records. Focus on status codes and error patterns.Identify the status code most correlated with latency spikes and explain the cause.

✅ Use this when: Customers report frequent mailbox failures or timeouts.

In this case, after planning it first generates a sql query joining the table and getting the 100 worst latency values.

This code is then executed to produce the result. An analysis gives likely causes.

📊 Interactive Failure Visualization

Use SQL to select all the rows with failure status from webmail table.

✅ Use this when: Customers report frequent mailbox failures.

LitenAI will generate the SQL code. Once executed, the results will be stored in an in-memory dataset for further analysis.

To generate an interactive visualization, prompt LitenAI to plot the data.

Plot the data.

Select appropriate values for X-axis, Y-axis, grouping, and filtering to enable interactive exploration.

📊 Visualize Access Failures and Trends

Create a bar chart of access attempts from client IPs from mailbox table. For each client IP, in the bar, show successful and failed attempts in different color.

✅ Use this when: Customers report frequent mailbox failures or timeouts.

It first generates python code.

Once executed it will show a plot like the following.

Research Agent: Obtain hidden insights from your data

Sometimes, you may want to take a broader view of an issue to uncover underlying insights. For example, in the case below, we analyze access failures to identify deeper patterns.

Meet the LitenAI Research Agent

LitenAI doesn’t stop at surface-level queries. The Research Agent conducts deeper, autonomous investigations—correlating logs, documents, tickets, and past incidents to uncover non-obvious insights. It builds a contextual understanding of system behavior over time, surfacing patterns and anomalies that typical tools miss.

This agent excels at exploratory analysis, incident retrospectives, and strategic debugging, drawing on:

Historical behavior patterns
Semantic understanding of documentation and prior tickets
Cross-source correlation using Smart Lake queries

How the Research Agent Operates Behind the Scenes

Planner Agent: Constructs a multi-step research plan to explore the problem space.
Search Agent: Identifies relevant logs, incidents, or knowledge assets.
Code Generator Agent: Writes optimized queries to probe hypotheses.
Execution Agent: Runs large-scale analysis over structured and unstructured data.
Analysis & Visualization Agents: Summarize results, identify anomalies, and present visual insights.

Example LitenAI Research on email access data

Before using these prompts, ensure the emailaccess database is selected, and your webmail and mailbox tables are available in the lake. Make sure that research is selected as Liten AI Agent.

Initiate the research by providing a prompt.

Perform a research analysis on mailbox access issues using the webmail and mailbox tables. Explore historical trends, status code patterns, and latency anomalies. Correlate failed access attempts by requestid and user over time. Use prior tickets or documentation if available to identify recurring issues or past resolutions. Summarize findings, highlight key insights, and recommend further areas of investigation if needed.

LitenAI begins by interpreting and clarifying the prompt.

Once the prompt is clarified, LitenAI begins the research process. Its research models evaluate the context and system activity, then dynamically invoke the appropriate tools to gather deeper insights.

The agent leverages its capabilities—such as reasoning, search, and analysis—to conduct an in-depth investigation.

In this case, it starts by retrieving relevant data, generating the necessary query code, and performing targeted analysis.

This is how a typical query can look like.

It then executes the query to retrieve the relevant data.

It then analyzes the data to extract further insights.

LitenAI performs several cycles of agentic reasoning to generate a list of insights. It then aggregates all relevant data and presents a comprehensive view of the issue.

In this case, the system surfaces key insights on status code errors, latency trends, failed access attempts, and recurring issues.

See below for a sample report.

Additional insights are listed below.

The Research Agent is highly effective at combining general knowledge with customer data and context to generate meaningful insights. It helps identify potential issues early, enabling proactive resolution.

🧪 Try It Yourself

You can drop your prompts, …and LitenAI agents will do the rest.

Try it now, click here!

Extracting Insights from Server Logs Using the LitenAI Research Agent

HK Verma — Sun, 01 Jun 2025 04:08:03 +0000

In modern cloud environments, valuable insights are often buried beneath noisy logs and fragmented metrics. At LitenAI, we’re building AI-powered research agents that autonomously explore operational data, uncover meaningful patterns, and surface hidden trends—without human intervention.

In this post, we demonstrate how a LitenAI research agent analyzed status code anomalies in server logs, revealing deeper insights behind recurring errors. The goal: to identify patterns that drive smarter operational decisions and continuous system improvement.

Defining the Research Prompt

The investigation began with a simple prompt:

Research the status code errors in the imapserverlog table. Focus on identifying internal server errors, analyze why they occurred, and explore how they can be fixed.

To enhance the depth of analysis, we expanded the scope to include grouping by error categories—4xx (client-side errors) and 5xx (server-side errors)—and requested a summary of key insights derived from each group.

Can you add more context and ask it to group by the type of errors – due to 4xx code, 5xx code etc. Also in the report, ask it to summarize the learning and insights using error groups.

Finally, once you confirm the research will start.

Yes it looks good.

The LitenAI chat can look like the following.

Once the research begins, LitenAI displays the selected topic. Below is the resulting output.

Research Workflow

The LitenAI Root Cause Agent autonomously selects the optimal workflow to investigate an issue. It sequences tools like log search, structured analysis, causal reasoning, and customer knowledge to uncover insights.

These are workflow steps.

Parse the research context

Starts from a user prompt or automated trigger to define the scope—log sources, error types, and time frame.

Retrieve relevant data

Generates and executes queries to extract relevant logs and errors.

Analyze and reason

Combines internal knowledge and external data to analyze patterns and derive insights.

Surface insights

Uses domain expertise and a tuned LitenAI model to uncover insights and anomalies.

Summarize Findings

Produces a structured report highlighting key insights and potential actions.

LitenAI Research Outputs

In this case it first gets the relevant data using SQL query.

This is the data that after executing the query.

It can then analyze the data for insights.

At the end, it first produces some insights.

It then produces a research output summarizing the research and insights.

How LitenAI Research Agent Helps

Unlike manual debugging workflows, LitenAI’s Reasoning Agent automatically:

Connects to structured logs (SQL, data lakes, or APIs)
Identifies patterns across multiple error classes
Synthesizes explanations grounded in system context
Presents insights with recommended next actions

All through a natural, conversational interface—empowering engineers to quickly understand system behavior and insights effectively.

Drill Down on the Research

LitenAI also offers agents like Data Explorer and Reasoning, allowing users to drill into data with full research context. These tools support deeper investigation and understanding of underlying insights.

🧪 Try It Yourself

You can drop prompts like –

Research status code spikes in service logs from last month, and explain why it keeps happening

…and LitenAI agents will do the rest.

Try it now, click here!

Diagnosing Service Incidents with LitenAI Root Cause Agent

HK Verma — Sun, 01 Jun 2025 04:07:45 +0000

In modern cloud-native systems, subtle error patterns hidden in log data can silently erode reliability—eventually leading to major outages. At LitenAI, we’ve built an intelligent Root Cause Agent that automates the analysis of such issues using natural language prompts, structured data reasoning, and contextual understanding. Powered by our MCP framework, the agent can integrate with tools like Jira, automatically triggering investigations as incidents are logged—analyzing the issue in real time, identifying the root cause, and suggesting or executing resolutions.

In this post, we demonstrate how the Root Cause Agent diagnoses a recurring service failure by analyzing status code data from system logs.

The Incident

The analysis can be triggered either by a user prompt or automatically when a new incident is logged. In this example, the issue was manually submitted by a user:

I have seen a bunch of errors in imapserverlog_. This is causing the service to fail once in a while with server error messages. Could you root cause?_

The agent responds like this –

You can modify the root cause prompt till it captures the whole issue.

Previously 4xx and 5xx type of errors have been seen. Please include them. Look for other errors as well.

Once the user confirms the prompt, the agent proceeds with the root cause analysis.

Yes, this looks good.

The prompt generation can look like this.

One the research prompt is completed, LitenAI will start the research.

Root Cause Workflow

The LitenAI Root Cause Agent autonomously determines the optimal workflow to investigate incidents. It intelligently selects and sequences tools such as log search, structured analysis, causal reasoning, and ranking algorithms to pinpoint the most likely root cause.

The agent executes the following steps:

Parse the incident context

The agent begins by processing either a user prompt or an automated trigger, identifying the relevant scope—such as log sources, error categories, and the timeframe.

Retrieve relevant data

It then generates a relevant query to extract error and other log data.

Analyze and reason

It evaluates the impact and frequency of each error, correlating them with system behavior and historical incident patterns to identify potential root causes.

Rank potential causes

It uses domain knowledge and a tuned LitenAI model to identify the most probable root cause based on the available evidence.

Compiled a structured report

It summarizes the findings, including error distributions, root causes, and recommended remediation steps.

LitenAI Root Cause Outputs

In this case it first gets the relevant data using SQL query.

Then it gets the data and performs multiple analysis and reasoning steps.

After a few minutes of analysis, the agent produces a report outlining potential causes. In this case, the IMAP service is experiencing a high volume of internal server errors, which require remediation. A follow-up root cause session can be initiated to explore resolution strategies. One possible mitigation is to roll back the recent changes.

How LitenAI Root Cause Agent Helps

Unlike manual debugging workflows, LitenAI Root Cause Agent automatically:

Connects to structured logs (SQL, data lakes, or APIs)
Identifies patterns across multiple error classes
Synthesizes explanations grounded in system context
Presents insights with recommended next actions

All through a natural, conversational interface—empowering SREs and developers to jump straight to solutions.

Drill down on the root cause

LitenAI also offers agents like Data Explorer and Reasoning, which allow users to drill down into the data with full context from the incident. These tools can be used to further investigate and understand the underlying issue.

🧪 Try It Yourself

You can drop prompts like –

Investigate status code spikes in service logs from last month, and explain the root causes.

…and LitenAI agents will do the rest.

Try it now, click here.

Building a simple Research Agent with MCP server on HTTP Streaming

HK Verma — Wed, 21 May 2025 01:35:20 +0000

Among the many emerging capabilities of large language models (LLMs), one of the most powerful is their ability to translate natural language into structured actions via API calls. This concept is formalized as “tools” in the OpenAI API. Model Context Protocol (MCP) builds on this idea by decoupling tools into standalone servers and clients. The result is a dynamic, agentic architecture where components can be composed, discovered, and orchestrated in real-time.

At LitenAI, we’re developing AI agents for data engineering, and we’ve adopted MCP to power them in production environments. In this post, I’ll walk you through how we used MCP to build a research agent that answers any question by recursively refining a prompt, conducting live web searches, and summarizing the results.

Agent Overview

The research agent is composed of three parts:

Prompt Refiner : Refines the user’s input into a clearer research question.
Web Searcher : Conducts iterative web searches using DuckDuckGo with AI reflections.
Summarizer : Synthesizes the search results into a professional report.

Here’s how the architecture works:

Step-by-Step Code Walkthrough

Let’s dive into the core components of the agent.

1. Environment Setup and Imports

We begin with the usual imports and initialization:

from openai import OpenAI
from duckduckgo_search import DDGS
from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
…
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

We also prepare a base message list to keep track of the conversation for refining prompts.

2. Prompt Refinement Function

This function uses OpenAI tools API to refine a vague user input into a sharp research prompt.

def refine_prompt(messages, prompt: str) -> tuple[bool, str]:
  tools = [{
    'type': 'function',
    'function': {
    "name": "refined_prompt_tool",
  …
  }
}]
messages.append({
  "role": "user",
  "content": f"Refine this topic into a clear research question: {prompt}"
})
completion = client.chat.completions.create(
  model="gpt-4",
  messages=messages,
  tools=tools
)
…

The function returns a tuple: the refined prompt and whether the user accepted it. MCP Server interacts with User till the prompt is refined.

3. Recursive Web Search

Once a refined prompt is ready, we search using DuckDuckGo API. We then ask the LLM to reflect on the result, and give a better phrasing based on it.

def search_and_reflect(search_prompt, research_messages, max_results: int = 2) -> str: ddgs = DDGS() results = ddgs.text(search_prompt, max_results=max_results) for i, result in enumerate(results): research_messages.append({ "role": "assistant", "content": f"[{result['title']}]({result['href']}): {result['body']}" }) research_messages.append({ "role": "user", "content": "Can you suggest a more focused follow-up search?" }) completion = client.chat.completions.create( model="gpt-4", messages=research_messages ) return completion.choices[0].message.content

We repeat this step iteration times (default 2–3) to improve coverage.

4. Summary Generation

Finally, we prompt the LLM to synthesize the entire research thread:

research_messages.append({ "role": "user", "content": "Write a concise and professional research summary from the context."})final_response = client.chat.completions.create( model="gpt-4", messages=research_messages)summary_text = final_response.choices[0].message.content

The summary becomes the output of our tool.

Wrapping it All in a MCP Server

To make this a deployable tool, we wrap the whole logic inside an MCP server with HTTP streaming support:

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
…
  return [types.TextContent(type="text", text=summary_text)]
  ...
  session_manager = StreamableHTTPSessionManager(
    app=app,
    event_store=None,
    json_response=json_response,
    stateless=True,
  )

Run it with bash from the github directory.

uv run mcp-research-agent

This can be tested using an MCP Inspector. See here for a test output image.

Why This Matters

Deploying MCP agents like this is non-trivial. Production workloads demand HTTP(S), secure data handling, and multi-node stateless operation. MCP now supports HTTP streaming , making it easier to deploy agents using standard protocols. This unlocks the possibility of plug-and-play agents that can interact with enterprise systems behind firewalls.

At LitenAI , we’re building AI agents to automate reasoning on enterprise data. This research agent is just one example of how MCP and LLMs can power complex, multi-step workflows in production environments.

Try it Yourself

Want to explore the code? It’s available here:

https://github.com/hkverma/research-mcp-agent

We at LitenAI love to hear your feedback or collaborate on use cases. Reach out!

Tutorial: Reason and analyze log data with LitenAI Agent

HK Verma — Fri, 28 Mar 2025 08:00:03 +0000

Our customers struggle to obtain effective technical answers using generic LLM and AU tools, as the responses were too broad and failed to address their specific issues. With our solution, we helped them ingest their data into LitenAI. Leveraging LitenAI AI Agentic flow, customers can now resolve issues in a targeted and efficient manner. LitenAI learns from existing knowledge to deliver precise, tailored answers using all data that meet their unique needs.

LitenAI is available now on demand. Please contact us to try it out now.

Here are some general steps to follow for resolving issues. Please note that this is a guideline script. LitenAI is a fully conversational agent and will respond to your prompts. While prompting, you may need to clarify the task that needs to be performed. In this Agentic flow, LitenAI accesses the necessary agents to perform the tasks and completes them. The system includes a combination of AI, a big data semantic engine, and a structural SQL query engine. For the following prompts, select logreason smart lake.

See a summary sheet below. Scroll down to see the prompts and expected response. Scroll further down below for lake tab settings.

Reasoning using LitenAI Agents

The Reasoning Agent is a top-level flow that plans and calls LitenAI agents to resolve customer questions. The LitenAI planner defines the flow, and each agent’s execution determines the next step until resolution.

For example, we can ask it to resolve an internal status error like this.

Reason out the internal status errors like 5xx in imapserverlog table. Analyze it for one most likely cause and give a resolution.

LitenAI first generates a plan as shown below.

The code generator agent creates accurate code by leveraging the smart lake and big data platform, which provide all necessary information for precision.

The code is executed on the LitenAI big data platform for interactive responses. LitenAI enhances query performance with tensorized data storage and an accelerator library.

Next, it performs an analysis to produce a final resolution.

LitenAI Agents

LitenAI agents are activated based on user prompts, enabling users to analyze data and explore specific areas of interest effectively.

Search Agents

We can first search through the open tickets and identify available engineers within the company using LitenAI’s search agents. See sample scripts below:

Search for the open tickets from tickets table.

There is a critical open ticket that needs attention. If necessary, we can use semantic search to identify available engineers and determine if the ticket should be assigned to them.

Can you search for an engineer with expertise to solve latency issues causing service disruptions from engineers table?

The system provides a list of engineers. Customers can either reassign tasks or request assistance from an engineer. Below is a sample chat illustrating how customers can perform these tasks.

Planning Agent

An engineer can request a plan to identify the root cause of latency issues in the email service.

Can you tell me how to root cause high latency values? Latency is measured by timestamp difference from imapserverlog to webaccesslog table. For now, provide high level direction without any code.

An engineer can request a plan to identify the root cause of latency issues in the email service. LitenAI analyzes customer flow and service logs to provide insights. Below is a sample chat demonstrating how an engineer can retrieve relevant data by joining tables.

Query and Execution Agents

Give me a plan to debug latency. latency is measured as timestamp difference from imapserverlog to webaccesslog table. These tables are joined by requestid fields. Pick the field names provided in the prompts. In the SQL, keep all the fields of both the tables in the output with names prepended with table abbreviations. Show 500 highest latency values. Execute the generated SQL.

After execution, the data can be reviewed. If needed you can confirm to execute the generated code like.

Execute the generated SQL.

This is executed on the big data cluster with accelerated Spark cluster. Sample dataset outputs are printed out as well.

Visualization Agent

Various plots can be created to visualize and interpret the information, which can also be shared if needed.

Plot the data.

The explorer plot can be seen below.

Analyze Agents

User can now ask for possible latency causes to understand if status codes could be an issue.

Can you analyze the possible causes of high latency focusing on status codes?

LitenAI reviews documents and data to identify potential causes.

Analyze to select one status code primarily responsible for latency degradation. Provide a resolution.

We can analyze specific causes to understand their impact on the service. By leveraging knowledge documents and historical data, LitenAI identifies the relevant code and suggests possible resolutions.

503 service not available is an issue here. LitenAI Engineer provides possible resolutions to the problem. Customers can chat with LitenAI Engineer to explore and drill down more into specific issues.

Smart Lake

In the LitenAI Smart Lake, the customer ingested their knowledge documents and established connections to their required databases. All data is securely stored within the customer’s storage. Customers can ingest data using various methods, either programmatically from stored files or through streams for continuous ingestion. Additionally, data can be uploaded and managed through Lake Agents, either via chat or using the Lake GUI interface to populate the lake. If you are going through these prompts, make sure to select logreason data lake. Select lake tab and ensure that logreason lake is selected. See a screen shot below.

We presented a sample session demonstrating how LitenAI can resolve customer issues. Our service is now available on the cloud. Please contact us to get started, we value your feedback and look forward to helping resolve your challenges.

Tutorial: Running LitenAI locally using python package

HK Verma — Wed, 26 Mar 2025 23:50:51 +0000

Introduction

Contact us to get the latest python package.

All data is local and accessible only to the user. LitenAI does not collect any data from user.

Prepare Your Environment

This Python package has been tested on Linux. For other operating systems, you can run it locally using LitenAI Docker image.

Ensure that Java version 17 is installed and in use. If not, do the following.

sudo apt install openjdk-17-jre-headless
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/

Ensure python version is greater than 3.12
Create a virtual environment for LitenAI under your preferred directory (in the command below replace /path/to/venvs with your desired install location)

python3 -m venv /path/to/venvs/litenaisource /path/to/venvs/litenai/bin/activate

Install LitenAI package

In all the following commands, replace with the actual version provided by the installer.

Extract the LitenAI package as given below; it should contain three items: a Python wheel file, a config file, and a lake directory.

tar -xvzf litenai-<version>.tgz

Change to the extracted directory, then install the LitenAI package using the provided .whl file. This will install all necessary LitenAI packages and the executable.

cd <litenai-version>pip install litenai-<version>-py3-none-any.whl

To install AutoGluon for CPU-only usage, use the following command:

pip install autogluon.tabular --extra-index-url https://download.pytorch.org/whl/cpu

Setup LitenAI Config files

LitenAI is highly configurable. Before the first run, edit the litenai-config.yml file.

In the LLM section, add your openai_api_key.

llm:
# LLM API key to for API calls
openai_api_key: "<Insert your key here>"

In the smartlake section of litenai-config.yml, replace /exact/path/to/lake with the local directory where the lake was extracted. All data will be in your local storage provided below.

liten:
# Liten lake root location
smartlake:
lake_url: 'file:/exact/path/to/lake'
lakestore: 'file:/exact/path/to/lake/litenailakestore.json'
# log files path
_log_dir: "/exact/path/to/lake/logs"

Start the LitenAI local service

Launch the service using the following command:

litenchat.sh -c ./litenai-config.yml

Once started, the service is typically available on port 8210. The URL and port are also printed in the terminal. On the first run, it discovers all ingested tables, which may take a few minutes. Subsequent starts should be much faster.

Open a Chrome browser and navigate to http://localhost:8210.

http://localhost:8210

It will launch the chatbot. You can find the login IDs in the litenai-config.yml files for reference.

Try out example chats

The installation includes a pre-loaded Smart Lake database. Explore various chat examples in the Articles section. These are some of the sessions available for you to try it out.

Tutorial: Reason and analyze log data with LitenAI Agent

Analyzing network packets

Automating Machine Operations and Support

LitenAI Agent: Transform raw data into reliable table

You can ask anything about ingested data or anything else. You can also ingest your data and ask LitenAI about this data.

For any issues or inquiries, feel free to contact us.

Tutorial: LitenAI Agent transforming raw data into reliable table

HK Verma — Fri, 21 Mar 2025 18:41:54 +0000

Our customers often spend significant time cleaning incoming raw data before it can be ingested into clean, structured tables. With LitenAI, these tasks can be performed simply by using natural language prompts. The agent reads the files, removes or modifies entries, and converts the data into the desired table structure or schema before writing it to a persistent table. This process reduces manual effort for engineers and empowers non-engineers to accomplish the same tasks effortlessly.

Previously, customers struggled to get precise answers from their AI chat tools — responses were too broad and failed to take context into account. In this solution, we ingest data into the LitenAI Smart Lake, and the LitenAI Agentic Flow completes the data processing based on customer requests.

In this blog, we demonstrate how this works through a chat interface, but it can also be used programmatically in notebooks via the litenai package.

LitenAI is available now on demand. Please contact us to try it out now.

In the smartlake, there are two tables one containing raw menu and another one cleaned up. The tables can be created when a file is ingested, or it can be created using LitenAI smart lake. Scroll down to see the lake details.

Below are the general steps showing how raw data can be cleaned and loaded:

Data table structures

We will start by reading the raw and JSON files into the Smart Lake. For this demonstration, I’ve created a new lake called menus, where all related tables and data will reside.

All incoming files are ingested into a table called menuraw. The fields and data types for this table can be automatically inferred from the content, so there’s no need to define the schema in advance. However, if the schema is already known, the table can also be created beforehand using a schema JSON structure.

You can describe and generate these tables using a simple natural language prompt.

Describe menus.menuraw table

Chat bot would show the menuraw table structure:

All cleaned up data is added to the menu table. You can view the structure of the menu table by using a prompt like this:

Describe menus.menu table

The following describes the menu table. You can view its schema and details here.

You’ll notice that the table structures differ, and some rows may contain incorrect information that needs to be cleaned.

Demo files are included with the Smart Lake. See the smart lake section below for instructions if you want to upload menu files.

Cleaning and writing the new table

You can review the menuraw table if needed. Use prompts like the ones below to explore its contents.

Count the number of rows in menus.menuraw table.

It will show the total rows outputs:

You can also search for rows having negative or null values.

Generate sql to select rows from menus.menuraw table any of its column having null entries or if price is negative. Execute the sql.

This should generate the sql and execute it.

You can use a prompt to generate code for the specific cleanup you need. Be as precise as possible in your request — this helps generate accurate code. The code can also be executed directly from the same prompt.

In this example, I’ll first generate the cleanup code and then run it.

Create python code for table menus.menuraw dropping all rows having negative price value. Create a dataset dropping all the rows with NULL in any of the fields. In this dataset, rename chain field to restaurant. Also, add another field called location. For ‘Casa Mexicana’ and ‘Maharaja Center’ restaurant, location should be San Jose. For ‘Mandarin House’ and ‘Olive Garden’ the location should be San Francisco. Save the final output dataset into menus.menu table. Use dfsout name for the final output dataset.

The generated code includes the available data and execution context. It is also validated to ensure accuracy. An example of the generated code is shown below.

This code can now be executed.

Execute the generated python code.

It would execute, and the following output is displayed.

You can review the output data or visualize it to ensure everything looks correct. Below are a few example prompts and their outputs.

Generate SQL to select 5 rows of menus.menu table. Execute the code.

Count the number of rows in menus.menu table

In the output, you can see that 12 rows were dropped due to invalid data. The row count decreased from 80 in menuraw to 68 in menu. You can also verify that a valid location is now included in the table.

Additionally, you can generate plots as needed to further inspect the data.

Generate python to plot the number of menu items grouped by integer values of price from menus.menu table. Use a bar graph.

Execute the code.

Smart Lake

In the LitenAI Smart Lake, the customer ingested their data and connected to their required databases. All data is securely stored within the customer’s own storage environment. Data can be ingested in multiple ways — either programmatically from stored files or through streaming for continuous ingestion. Additionally, data can be uploaded and managed using Lake Agents, either via chat or through the Lake GUI.

If you are following along with these prompts, make sure to select the menus data lake. Go to the Lake tab and ensure that menus lake is selected. See the screenshot below for reference.

We can load files into the menuraw table. The demo files are loaded with the litenai demo. However, to load them, simply select a file from the menu and click the Ingest button as shown below.

In this example, we demonstrated how data can be cleaned and loaded into another table using simple prompts. With LitenAI, data engineering tasks that once required manual effort from engineers can now be handled automatically by intelligent agents. These agents can understand instructions, generate the necessary code, and execute the operations seamlessly. This not only saves time but also makes complex data tasks accessible to non-engineers.

Please contact us to get started, we value your feedback and look forward to helping resolve your challenges.

Tutorial: Automating Machine Operations and Support

HK Verma — Fri, 21 Mar 2025 18:11:32 +0000

In this use case, the customer owns an expensive MRI machine that requires regular servicing or repairs. LitenAI assists technicians through a conversational interface, providing expert information sourced from ingested manuals and log data. By consolidating all data into its Smart Data Lake, LitenAI enables intelligent searches and in-depth analysis. The LitenAI Agent leverages this data to identify patterns and provide precise technical support for these devices.

Preventive maintenance tasks are routinely carried out. Below is a chat session illustrating a preventive maintenance interaction between a technician and the system.

If you are running these chats from Liten demo lake, make sure that you select techassist as your lake. Scroll down below for the smart lake settings to be used.

Preventive Maintenance

Customers can simply request tasks to be performed on a machine. In this example, we have ingested an MRI machine manual to demonstrate the process. You can ask a question like this.

I need help with quarterly maintenance of Philips MRI machine. Do not provide details. Include any test images.

The answer provided is specific and derived directly from the ingested data, ensuring relevance over generic responses.

Customers can now query the service record table to review previous maintenance work. They can access the latest records and learn from them as needed.

Query the servicerecord to show me the PMs done on this MRI machine.

This query performs a search on the service record table.

Customers can request specific steps for each test and ask clarifying questions as needed.

Provide me exact names of test that are part of Calibration Checks for MRI machines from manuals. Don’t include any details on the steps.

In the example below, steps for medical field tests are provided, derived directly from customer-ingested documents.

Show me the exact setup steps for medical field homogeneity test from manuals. Do not include details.

Once completed, customers can generate reports and add them to the records if needed. Agents can also be customized to ensure the report format aligns with customer requirements.

Generate report showing the test result and setup using manuals.

Break Fix

When machines break down, they need to be repaired as quickly as possible to minimize operating costs. LitenAI assists technicians by providing expert answers, reducing delays and idle time caused by waiting for human experts. Customers can initiate troubleshooting by describing the problem they observe in the system.

Image produced is noisy and does not look correct. Can you suggest me a few fixes from Philips Insignia MRI manual.

Customers can now inquire about additional scenarios and explore various possibilities.

Tried these steps, but did not fix the issue. Could a faulty coil be an issue?

Machine logs are available in the LitenAI Smart Lake, allowing customers to search for failures or anomalies. LitenAI leverages big data technology to securely store all data and elastically scale to accommodate large log volumes.

Query using sql for fault or gradient in message field of mrilogs table.

Customer can now ask for exact steps to fix this possible issue.

From the manual, tell me exact steps to fix coil failures. Include any test images.

Customers can now generate detailed reports.

Can you create a text report with headers and tables summarizing the work done on break fix.

The report includes a conclusion, and the reporting agent can be customized as needed. Reports can also be recorded in a table if required.

Reasoning Agent

In reasoning agent, a technician poses a high-level question, and LitenAI generates a plan, executing steps to provide a final answer.

Can you reason out and provide a single resolution. My Phillips MRI machine has been giving incorrect images. Look for faulty or gradient in mrilogs table. See if that is an issues. If not, look for other causes of failures. I want you to analyze and come back with the most likely cause of failure.

LitenAI first generates a plan.

It then generates the query code and runs it on LitenAI accelerated big data platform.

It then analyzes it and generates the likely cause of failure.

The reasoning agent enhances its accuracy and effectiveness as LitenAI’s Smart Lake ingests more data and users engage with the agents.

Business Analytics

LitenAI securely stores machine data and customer documents within customer-controlled storage. The LitenAI Agent enables the extraction and visualization of various metrics and trends for business purposes.

This example examines the service record to analyze the number of tasks completed daily over the course of a year.

For servicerecord table, use sql to count the number of rows for every day before year 2020. Execute the generated SQL.

Data can also be plotted and shared for better visualization and communication.

Plot the data in line.

Using LitenAI agents, analytics can be completed on this data. Reports and plots can be generated to help with understanding the machine usage as well as its failures among other tasks. These all get done using a conversational interface.

Smart Lake

In the LitenAI Smart Lake, the customer ingested their knowledge documents and established connections to their required databases. All data is securely stored within the customer’s storage. Customers can ingest data using various methods, either programmatically from stored files or through streams for continuous ingestion. Additionally, data can be uploaded and managed through Lake Agents, either via chat or using the Lake GUI interface to populate the lake. If you are going through these prompts, make sure to select techassist data lake. Select lake tab and ensure that techassist lake is selected. See a screen shot below.

Tutorial: Analyzing network packets

HK Verma — Thu, 20 Mar 2025 22:40:09 +0000

LitenAI supports uploading packet files in PCAP format, storing all packets in its Smart Lake. For demonstration, a table named pcap has been created in the LogReason Smart Lake. It can ingest large volumes of packet data for analysis. While PCAP files are currently used, any network-related log files can be uploaded and analyzed using LitenAI.

Scroll down for chat examples. Scroll further down for more information on LitenAI Smart Lake.

LitenAI supports high-level reasoning and detailed packet analysis. Below are some examples, but it can be applied to many other use cases. Contact us to test it with your data—either on our cloud platform or locally via a Docker installation.

General Analysis

Users can ask high-level questions, and LitenAI will generate a structured plan to analyze network congestion based on the provided prompt. You can also explore specific details—scroll down to see examples.

Generate sql to find out the number of packets between src_ip and dst_ip for each protocol type from the pcap table. Execute the sql.

This generates and executes the code, then displays the resulting rows with the relevant information.

Ask any question to analyze the data.

Analyze the data to tell me more about the overloaded IP addresses.

You can also explore it as a plot, if needed.

Plot the dataset.

LitenAI can extract various types of information from packets to analyze congestion more effectively.

Understanding packet contents

LitenAI helps you analyze and understand your packets more effectively. It can interpret packet data and respond to your queries through chat. Think of it as a valuable addition to Wireshark.

First, obtain the packets for analysis. Let’s start with a row. For now, TCP layers are excluded, but you can include them if needed for a more comprehensive TCP analysis.

Select one packet row from pcap table without layers_tcp column using sql and execute it,

The packet is stored in a dataset and displayed. You can now ask LitenAI to describe the packet and its contents.

Describe the dataset.

It presents all packet information in a clear and readable format.

You can now query the packet for various types of information. Here are a few examples:

Analyze the data to tell me the application protocol used to transfer files from PC to server?

Analyze the data to tell me the IP address of the server.

Various other questions related to packets can be asked, and it will provide answers. Through calls to large language models (LLMs), it understands multiple natural languages and can respond appropriately.

Upload the packet you’re interested in and ask your question. You can also filter specific packets or columns to focus on relevant data. LitenAI will help you find the right packet efficiently.

Various types of packets with different protocols can be analyzed. Below is an analysis of a DHCP packet.

Select one packet row with dhcp protocol using sql and execute it.

Analyze to tell me the DHCP server IP address?

Analyze the data to visualize this DHCP exchange in ascii?

This produces DHCP exchange in ASCII as shown below.

Analyze the data to get a mind map of 4 dhcp frames and highlight latency?

This generates a detailed mind map. Below is a small sample for reference.

Here is more information about the LitenAI Smart Lake Storage Layer.

Smart Lake

To ingest a new file, you can select pcap type and choose a file. Click on Ingest. It will append the pcap information to pcap table.

This blog highlights the capabilities of AI in analyzing network packets. Various types of analysis can be performed, and customers can integrate their own agents for specific tasks. Contact usfor more information.

Tutorial: Running LitenAI Locally using Docker Image

HK Verma — Mon, 10 Mar 2025 22:09:41 +0000

Introduction

Contact us to get the latest docker image.

All data is local and accessible only to the user. LitenAI does not collect any data from user.

Installation Steps

Prepare Your Environment

Ensure Docker is installed and running.
Confirm your user is part of the Docker group. For assistance, follow the Docker post-install guide.

Load the Docker Image

Download the Docker image from the LitenAI Store.
Load the image using the following command. Version is the release version number like v0.1.112

docker load < litenai.<version>.tar.gz

Verify the image load with the below command. Note down the tag number, it will be needed to start the container.

docker image ls

Set Environment Variables

Set your API key to a valid Azure, OpenAI or local API key

export LITENAI_API_KEY="api_key"

Bring up the docker container

Replace with the number from ‘docker image ls’ command above

docker run -d --name litenai_container -p 8210:8210 -p 8221:8221 -e LITENAI_API_KEY=${LITENAI_API_KEY} litenai/litenai:<tag>

Access the Chat Interface in your local browser, by visiting the URL below

http://localhost:8210

Stop the container

docker stop litenai_container

Sample Chat Sessions

Access the Chat Interface in your local browser, by visiting the URL below

http://localhost:8210

Click on the Lake tab. The Docker environment comes pre-loaded with two lakes: logreason and techassist.

To explore the logreason lake, select it from the Lake tab. You can then follow the sample chat session described in the blog to understand how to analyze customer sessions and identify the root causes of performance issues.

To explore the techassist lake, select it from the Lake tab. After the lake loads, you can follow the sample chat session described in the blog to understand how technicians maintain and repair medical devices.

Configuration for Self-hosted LLM

LitenAI supports the use of locally hosted LLMs. To configure this, you need to provide the URL for the LLM call and specify the LLM model being used. An example configuration is shown below.

Set Environment Variables

export LITENAI_SERVE_URL="http://localhost:8000/v1"export LITENAI_LLM_MODEL="meta-llama/Llama-3.2-1B-Instruct"

Run the Docker command below

docker run -d --name liten_container -p 8210:8210 -p 8221:8221 -e LITENAI_API_KEY=${LITENAI_API_KEY} -e LITENAI_SERVE_URL=${LITENAI_SERVE_URL} -e LITENAI_LLM_MODEL=${LITENAI_LLM_MODEL} -e LITENAI_AZURE_API_VERSION="" litenai/litenai:<tag>

Access the Chat Interface in your local browser, by visiting the URL below

http://localhost:8210

Configuration for OpenAI Service

LitenAI is configured to use the Azure OpenAI service by default. However, it can also integrate with the OpenAI service.

Set Environment Variables

You will need to obtain an OpenAI API key from your OpenAI account.

export LITENAI_API_KEY=<OpenAI-API-Key>

Run the Docker command below

Set the serve URL and Azure API versions to empty values.

docker run -d --name liten_container -p 8210:8210 -p 8221:8221 -e LITENAI_API_KEY=${LITENAI_API_KEY} -e LITENAI_SERVE_URL="" -e LITENAI_AZURE_API_VERSION="" litenai/litenai:<tag>

Access the Chat Interface in your local browser, by visiting the URL below

http://localhost:8210