DEV Community: Anuroop

Why is everyone panicking about AI?

Anuroop — Thu, 05 Mar 2026 16:19:42 +0000

Most of what we see online regarding AI are the two extremes, either complete apocalypse or curing cancer. But like most things, the truth seems to be somewhere in the middle.

What is an LLM?

LLMs are machine learning models trained on petabytes of data to predict patterns in language. Current models have become very capable of doing this. This has people worried about the emergence of sentient behaviour or self preservation tendencies in LLMs. Today thanks to libraries like LiveKit, it's easier than ever to create a multimodal AI system that can produce coherent responses based on not just text, but also image and voice input.
Although this might seem groundbreaking, underneath, the model is still processing text tokens. Most systems use a separate vision or speech to text model for multimodality.

Does AI have preservation tendencies?

Current models do show behaviour that appears to prioritise self preservation over saving humans in certain situations, as pointed out in papers published by Anthropic, OpenAI and others.
People often remark how these models can't really think or have emotions. However, a system doesn't need emotions or human like cognition to cause immense changes in our lifestyles and even harm Flash Crash 2010 is a good example of this, where automated trading algorithms caused a near economic collapse.

One of the major concerns that bothers me is being unable to distinguish between what aspects of the current AI progress is just hype for pulling in investment and what is based on real development. Companies are heavily investing time, money, and talent in implementing AI even though new reports show that the ROI is extremely bad. But is AI really going to work in the long term? Is it really going to improve at the pace we are told? Will it really be good enough to replace human engineers?
Would it help us formulate our thoughts better or would it dilute our reasoning?

These are HARD questions to answer.
The problem is that we are trying to predict the future based on little to no data.

Is AI progress rapid?

When people say that AI progresses at a rapid pace, they often discard the decades of research prior to the "AI Boom" (which is typically marked by the release of chatgpt 3.5). What about the backpropagation research papers published around 1960s? How about RNN research papers from 1990s? Or the LSTM papers of 1997s? These were fundamental for the development of AI and ML. Ignoring these is simply ignorant and naiive.

I made a python package to store AI generated images along with their context (prompt, model info, etc)

Anuroop — Sun, 04 Jan 2026 02:37:09 +0000

Hey y'all, I made a python package that takes an image, it's context like the prompt, model name, hardware info, generation settings (e.g sampler settings),etc and also has 2 distinctive features:

Can store Latent tensors
Has a environment chunk that screates canonical strings of the e verisoning and stuff of critical libraries and hardware (eg pytorch, gpu drivers, OS, CPU cores etc. ) and hashes them and uses it to detect environment drift!

Check the repo and feel free to star it!!
https://github.com/AnuroopVJ/gen5

How do Transformer Models work?

Anuroop — Sun, 31 Aug 2025 15:44:21 +0000

What are Transformer Models?

Transformer models are a type of AI architecture that revolutionized how computers understand and generate text. Think of them as super-powered pattern recognition systems that can process entire sentences at once, rather than word by word like older models. Their ability to understand context and capture meaning is what sets them apart.

Just a quick disclaimer… This is a simplified explanation.

So let’s get started!

Tokens and vectors
Firstly, let’s briefly understand what vectors and tokens are, as we will be using these terms frequently.

Consider this sentence: “I love coding”

Tokenization

When this gets fed into a tokenization engine, it splits this into pieces like ‘I’, ‘love’, ‘coding’, or sometimes even smaller chunks like ‘I’, ‘lo’, ‘ve’, ‘cod’, ‘ing’, depending on the tokenization method. These splits are called tokens.

And when we represent them in terms of numbers, we get Vectors!

Model Weights
Before moving further, let’s also take a look at model weights.

Think of knobs that, during the training process, the model/AI “tweaks” based on it’s generated output. These can be referred to as model weights. Here’s how training works: We give the model some input text and show it what the expected output should be. The model generates its output, and then we measure how different it is from what we wanted. Based on that difference, the AI adjusts all those knobs (weights) to get better at producing the right output. This happens millions of times until the model gets good at it!

Query, Key, Value vectors & Attention Mechanism

After the input is tokenized and converted to vectors, here’s where it gets interesting. Using the model weights, we transform each input vector into three different types of vectors:

Query vector (what this token is “asking about”)
Key vector (what this token is supposed to “represent”)
Value vector (the actual “info” this token carries)
This transformation is done by multiplying each input vector by the model weights. Then we feed all these into the Attention Mechanism. What this does is the model takes each token’s query vector and compares it with ALL the key vectors in the sentence (including its own). This gives us Attention scores, aka Attention Weights.

This is a vector that tells the model which tokens to pay attention to.

Here’s an example to understand this better:

The model takes each token’s query vector and compares it with ALL the key vectors in the sentence (including its own). This comparison gives us attention scores — basically telling the model :

“When processing this word, pay **THIS **much attention to that other word.”

For example, in

“The cat sat on the mat”

When processing “sat,” the AI might pay more attention to “cat” (who’s doing the sitting) and “mat” (where the sitting happens).

Contextual Representation and Prediction
These attention scores get multiplied by the corresponding value vectors and added together. This creates what we call a

contextualized representation: a vector that captures not just what this word means, but what it means in this specific context, given everything around it.

Then the dot product (for simplicity, you can think of this as just multiplying, but it helps to know exactly what taking a dot product means) of this vector with a matrix (think of this as a collection of vectors) containing all possible vectors that the model knows. The attention layers and all the other components of such a model, including these vectors, are also adjusted and learned during training.

So after taking that dot product, it gets scores for each token, and it takes the token with the highest score or uses sampling techniques to randomly choose between the highest ranking tokens and provides it as the output!

And that’s how AI generates the next word! This process repeats for each word in the response until it decides it’s done.

Thank you for reading!

How I created a research agent with langgraph

Anuroop — Sun, 31 Aug 2025 05:03:03 +0000

Introduction
Hey! In this article I'm going to share with you my process of how I created a research agent with 'langflow'. This project is hosted on: sci-ai.streamlit.app

Tech stack

streamlit for frontend
langgraph
some langchain components
arxiv api
semanticscholar api
groq api for llm inference

Outline

Setting up Langraph :

from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langchain.chat_models import init_chat_model

Langgraph (which uses langchain underneath for some of the processing) is an agent orchestration library that is more organised and mature compared to just langchain.

Now, let's import other necessary libraries as well:

from pydantic import BaseModel, Field
from typing_extensions import TypedDict
from typing import Annotated
from langchain_community.document_loaders import ArxivLoader
from semanticscholar import SemanticScholar
from langchain_community.utilities.semanticscholar import SemanticScholarAPIWrapper
import streamlit as st
import os

from io import BytesIO
import subprocess
import sys
# Load environment variables
load_dotenv()

We are using semanticscholar api and arxiv as credible sources for scientific research papers.For the sake of quick searching, we also use DDGS api [duckduckgo api]. Instead of writting the whole api request code from scratch, we make use of prebuilt tools provided by langchain for all of these. Why rebuild the wheel right?

api_key = st.secrets["GROQ_API_KEY"]

# Initialize LLM
llm = init_chat_model(
    "groq:llama3-8b-8192",
    api_key=api_key
)

if api_key:
    print("Auth_key_found")
    st.info("Auth_key_found")

Arxiv = []
ss = []
s = SemanticScholar()
sch = SemanticScholarAPIWrapper(
    semanticscholar_search=s,
    top_k_results=3,
    load_max_docs=3
)

Here we initialise the semanticscholar class from the library, load the api key for groq api (llm inference) from the 'secrets.toml' file that you need to create in your file hierarchy.
The location of that file should be inside of a folder named '.streamlit' (current_working_directory/.streamlit/secrets.toml)

File hierarchy:

current_working_directory
└── .streamlit
    └── secrets.toml

sch = SemanticScholarAPIWrapper(
    semanticscholar_search=s,
    top_k_results=3,
    load_max_docs=3
)

This is where we specify the number of papers we want to analyse. Remember that the more papers you decide to use, the more tokens the llm would need to process the data but the better the output is going to be. I found the sweet spot to be around 3-5 papers.

class State(TypedDict):
    messages: Annotated[list, add_messages]
    search_queries_arxiv: list[str]
    search_queries_semanticscholar: list[str]

class Search_query(BaseModel):
    queries_arxiv: list[str] = Field(..., description="list of queries for serching arxiv")
    queries_semanticscholar: list[str] = Field(..., description="list of queries for serching semanticscholar")

# Build LangGraph
graph_builder = StateGraph(State)

Here we define a class named State that inherits the TypedDict class from the typing library. So whatever we define here is like a form the LLM can fill out(except for the 'messeges' one)! The messeges' one is defined as an Nnotated list since we want to store the history here. In my usecase, I have defined 2 other fields for the LLM to fill based on the topic given by user, which are : 'search_queries_arxiv','search_queries_semanticscholar'.
This is were the LLM generates the search queries to be searched about with the arxiv api and semanticscholar api.But remember that this is just definition we have not yet invoked the LLM to actually do the action of filling the fields. Think of this as just printing out a form you designed verses the filling out of the form by someone.

In order to generate a graph (let the llm full the fields we defined in state class), we feed the state class into the state-graph function of the langgraph library.

def query_construct(state: State):
    structured_llm = llm.with_structured_output(Search_query)
    last_message = state["messages"][-1]
    user_message = last_message.content if hasattr(last_message, "content") else last_message["content"]

    prompt = f"Based on this user request: '{user_message}', generate 2-3 specific search queries for finding relevant scientific papers."

    search_query_obj = structured_llm.invoke(prompt)

    if isinstance(search_query_obj, dict):
        queries_arxiv = search_query_obj.get("queries_arxiv", [])
        queries_semanticscholar = search_query_obj.get("queries_semanticscholar", [])
    else:
        queries_arxiv = getattr(search_query_obj, "queries_arxiv", [])
        queries_semanticscholar = getattr(search_query_obj, "queries_semanticscholar", [])

    return {"search_queries_arxiv": queries_arxiv, "search_queries_semanticscholar": queries_semanticscholar}

It is through this function that we actually ask the LLM to fill in the fields we defined earlier.

def source_aggregator(state: State):
    queries = state.get("search_queries_arxiv", [])
    queries_SS = state.get("search_queries_semanticscholar", [])

    for q in queries:
        try:
            st.write(f"Searching Arxiv for: {q}")
            loader = ArxivLoader(query=q, load_max_docs=1)
            docs = loader.get_summaries_as_docs()
            Arxiv.append(docs)
        except Exception as e:
            st.write(f"Error: {e}")
            Arxiv.append(f"Error: {e}")

    for qs in queries_SS:
        st.write(f"Searching SemanticScholar for: {qs}")
        r = sch.run(qs)
        ss.append(r.get('abstract', '') if isinstance(r, dict) else None)

    combined_info = f"Arxiv: {Arxiv}\nSemanticScholar: {ss}"
    return {"messages": [{"role": "system", "content": combined_info}]}

This function is what searches for papers based on search terms on arxiv & semanticscholar APIs. First it accesses the search queries generated by the api via:

queries = state.get("search_queries_arxiv", [])
    queries_SS = state.get("search_queries_semanticscholar", [])

Then we define a for loop that goes through each of the search query and searches them with the above mentioned APIs and appends them into their respective lists. This list is what containers the info to be processed by 'parse_headings_and_body' function.

def parse_headings_and_body(text):
    paragraphs = []
    for line in text.strip().split("\n"):
        line = line.strip()
        if line.startswith("**") and "**" in line:
            heading = line[3:line.index("]**")]
            paragraphs.append(("heading", heading))
        elif line:
            paragraphs.append(("body", line))
    return paragraphs

This is a function we are defining to parse headings and body(split into paragraphs) of the paper, before feeding into the llm.
We do so by first declaring a variable named paragraphs holding a list. Then we define a for-loop which extracts paragraphs by looking for '**' which is used to bolden given text by LLMs in their response for headings or subheadings. Then we append these into the list named paragraphs that we declared earlier. Then we return it.

def data_synthesis(state: State):
    return {"messages": [llm.invoke(state["messages"])]}

This function just invokes the LLM to generate the report based on data given!

if st.button("Analyze") and usr_inp:
    with st.spinner("Preparing your report..."):
        # Build graph
        graph_builder.add_node("query_construct", query_construct)
        graph_builder.add_node("source_aggregator", source_aggregator)
        graph_builder.add_node("data_synthesis", data_synthesis)

        graph_builder.add_edge(START, "query_construct")
        graph_builder.add_edge("query_construct", "source_aggregator")
        graph_builder.add_edge("source_aggregator", "data_synthesis")
        graph_builder.add_edge("data_synthesis", END)

        graph = graph_builder.compile()
        state = graph.invoke({"messages": [{"role": "user", "content": usr_inp}], "search_queries": []})

        parsed_resp = state['messages'][-1].content
        st.write(parsed_resp)
        text_file = BytesIO(parsed_resp.encode('utf-8'))
        # Download button
        st.download_button(
            label="Download Report (txt)",
            data=text_file,
            file_name="Report.txt",
            mime="text/plain",
            icon="📄",
        )

Here is where we do the 'orchestration' aspect of this project. Let's see a basic diagram to better understand this:

And that's it!