Forem: Pranav Munigala

BlastAI Program

Pranav Munigala — Wed, 02 Jul 2025 20:51:57 +0000

Recently, I created another biopython program to further my expertise in this field. Using BLAST (Basic Local Alignment Search Tool), an algorithm that compares biological sequences, such as DNA or protein sequences. To become familiar with this tool, I decided to create a program that takes in a sequence from the user, then runs BLAST on it, looking for alignments. Then, for people who are not so familiar with what it is) using an LLM, it explains what the results signify so the user can interpret it better.

Let me explain how the program works:

First I had to get the user input in BLAST format. Also asking which type of blast program they want (blastn or blastp). BLASTn compares a nucleotide sequence to a nucleotide database, while BLASTp compares a protein sequence to a protein database.

Code:

# User Input
fasta_input = st.text_area("🧬 Enter your FASTA sequence", height=150, value=">example\nATGCGTACGTAGCTAGCTAGCTAGCTAGCTGACT")

blast_program = st.selectbox("⚙️ Select BLAST program", ["blastn", "blastp"])
database = "nt" if blast_program == "blastn" else "nr"

Then I had to create the blast function using fasta input. Here is the code:

# Run BLAST
if st.button("🚀 Run BLAST and Explain"):
    if not fasta_input.startswith(">"):
        st.error("Please provide a valid FASTA format (must start with '>').")
    else:
        try:
            with st.spinner("Submitting BLAST to NCBI..."):
                result_handle = NCBIWWW.qblast(blast_program, database, fasta_input)

            with st.spinner("Parsing BLAST results..."):
                blast_record = NCBIXML.read(result_handle)
                alignment_summaries = ""

                for alignment in blast_record.alignments[:3]:
                    for hsp in alignment.hsps:
                        if hsp.expect < 0.001:
                            alignment_summaries += f"""
Match: {alignment.hit_def}
E-value: {hsp.expect}
Score: {hsp.score}
Identities: {hsp.identities}/{hsp.align_length}
Query: {hsp.query[:60]}...
Subject: {hsp.sbjct[:60]}...
---
"""
                            break  # only one HSP per hit

A FASTA sequence is a text format that represents biological sequences such as DNA or proteins. For the BLAST to work the fasta sequence inputted HAS to begin with > followed by a sequence identifier. So the first part checks if it is valid or not.

Next the NCBIWWW.qblast function sends the BLAST request to NCBI servers. The parameters are

blast_program:the BLAST algorithm to use
database:the target database
fasta_input: the sequence enterd in FASTA format
result_handle : a file-like object containing the BLAST XML result.

Then the function NCBIXML.read() parses the XML returned by NCBI into an object called blast_record.

Now under alignment summaries it appends a summary for each significant match.

alignment.hit_def: description of the matched sequence.

hsp.score: the alignment score.

hsp.identities: how many positions match exactly.

hsp.query[:60] and hsp.sbjct[:60]: shows first 60 bases of the aligned query and subject segments (truncated for readability).

After this comes the LLM part. Using variables and prompt template I created a simple LLM that explains what is going on in the BLAST program.

# Use OpenAI to explain
                st.subheader("🤖 GPT Explanation")
                with st.spinner("Generating explanation..."):
                    prompt = f"""
You are a bioinformatics tutor. Explain the following BLAST results to a high school student in simple terms.

Here are the matches:

{alignment_summaries}

Explain:
- If the sequence matched anything known
- What organisms the matches came from
- How strong the matches were
- What alignments or similarities were found

Keep your explanation under 500 tokens. Be clear and easy to understand.
"""
                    try:
                        response = client.chat.completions.create(
                            model="gpt-4",
                            messages=[{"role": "user", "content": prompt}],
                            max_tokens=300,
                            temperature=0.5
                        )
                        explanation = response.choices[0].message.content
                        st.write(explanation)
                    except Exception as e:
                        st.error(f"Error generating explanation: {str(e)}")
                        st.info("Please check your OpenAI API key in the .env file.")
            else:
                st.warning("No strong hits found (E-value < 0.001). Try another sequence.")

        except Exception as e:
            st.error(f"Error running BLAST: {str(e)}")
            st.info("Please check your internet connection and try again.")

It is always important for the LLM to know its role. In this case, I assigned it the role of a "bioinformatics tutor," so it knows what to focus on.

Here is a video of the program in action: https://youtu.be/edJgN316OXA

As always, please let me know if you have any suggestions on the code or even any advice on what to do next (or to make this program better).

Protein Structure & Function Investigator

Pranav Munigala — Sun, 29 Jun 2025 15:55:21 +0000

Today, I would like to share a new program that I created in my journey to learn more about bioinformatics and biopython. This is the second project I undertook in this bioinformatics series, which involves investigating protein structure and function.

What the program is supposed to do: Take user input in PBID (Protein Data Bank ID) form and return the 3D visual structure of the protein, and can interact with an AI agent that can read its file to answer specific questions about it.

To create this program, I needed to use BioPython's PDB module, which takes a 4-character PDB ID and downloads the corresponding .pdb file. Then, using functions within this module, the output can be parsed so it is easier to read by the AI module and easier to work with in the code. Some key features that can be taken from a PDB file for a protein are structure resolution, secondary structure elements, and amino acid sequence (and many more).

Overall, these are the tools that I used:

Tech: Python, Streamlit, LangChain Agents.
Tools: BioPython (PDB module), Py3Dmol (for 3D visualization in Streamlit).
Data: Live data from the Protein Data Bank (PDB).

Now let's dive into the code for the program. I split this up into a couple of key parts and steps:

Getting the input and setting up a download path

pdb_id_input = st.text_input("Enter a PDB ID (e.g., 1TUP):", value="1TUP").lower().strip()
download_path = "pdb_files"

This PDB module needs a space for all files to be saved, and for that I needed to setup a file path so that for every different input a new file would be created in that folder and the program would be able to access that information.

Parsing the input after getting the file and saving it to a variable named "info"

if pdb_id_input:
    pdbl = PDBList()
    file_path = pdbl.retrieve_pdb_file(pdb_id_input, pdir=download_path, file_format="pdb")

    parser = PDBParser(QUIET=True)
    structure = parser.get_structure(pdb_id_input, file_path)

    # Extract structure info
    model = structure[0]
    chains = list(model.get_chains())
    residues = list(model.get_residues())
    atoms = list(model.get_atoms())

    # Create the `info` string with summary
    info = f"""
PDB ID: {pdb_id_input.upper()}
Structure Name: {structure.header.get('name', 'N/A')}
Experiment Method: {structure.header.get('structure_method', 'N/A')}
Resolution: {structure.header.get('resolution', 'N/A')} Å

Number of Chains: {len(chains)}
Chain IDs: {[chain.id for chain in chains]}
Number of Residues: {len(residues)}
Number of Atoms: {len(atoms)}
"""

Here, I used a PDBParser, which is already trained to parse through this type of information and organize the information so that it is easier to extract. In addition, the data is in columns and rows, so you can see that to get the model, for example, it would be structure0. From the model, you can also get a lot of other information, like the chains, residues, and atoms. This information is very common, so I wanted to ensure that it was part of the variable that I created.

Creating the "info" variable, I made sure to save a couple of key features like the ID, the structure name, experiment method, resolution, chains, chain IDs, atoms, and residues. The PDB file is very large, so I thought these would be the most important ones to include.


# Output
    st.subheader("Structure Info:")
    st.code(info)

     # --- 3D Visualization ---
    st.subheader("🧬 3D Structure Viewer")
    with open(file_path, "r") as f:
        pdb_data = f.read()

    view = py3Dmol.view(width=700, height=500)
    view.addModel(pdb_data, "pdb")
    view.setStyle({'cartoon': {'color': 'spectrum'}})
    view.zoomTo()

    view_html = view._make_html()
    st.components.v1.html(view_html, height=500, width=700)

This block of code is to visualize the protein structure which is also within the PDB file. Here, I researched syntax and came up with this basic layout for protein structure visualization in the program. Below is an example of what it would look like:

Setting up the LLM with all the necessary information.

# Ask if user has a question
    st.subheader("🤖 Ask About the Structure")
    ask_question = st.radio("Do you have any questions?", ["No", "Yes"])

    if ask_question == "Yes":
        user_question = st.text_input("Enter your question about this structure:")

        if user_question:
            # Initialize LLM
            llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.4, max_tokens=300)

            # Prompt Template
            prompt = PromptTemplate(
                input_variables=["pdb_id", "info", "question"],
                template="""
You are an expert in protein structures. Given the following:

PDB ID: {pdb_id}
Structure Info:
{info}

Answer this question:
{question}

Make sure the answer is simple enough for a highschool student to understand
"""
            )

            chain = LLMChain(llm=llm, prompt=prompt)
            response = chain.run({
                "pdb_id": pdb_id_input.upper(),
                "info": info,
                "question": user_question
            })

Through lots of practice, I thought it was pretty simple to do this part of the program. First, I prompted the user to say yes or no if they had any questions. If yes, they would be prompted to type in their question, and it would be saved in a temporary variable. Then I initialized the LLM, created a simple prompt template passing in the variables. Finally, the answer would be returned.

Just an FYI, all of my Streamlit UI was integrated between these parts. I thought it would be easier to incorporate it into each part of the program.

Here is a brief walkthrough of the program in action: https://youtu.be/6UzOTgFaA9c

Central Dogma Explorer

Pranav Munigala — Sun, 22 Jun 2025 14:13:14 +0000

Recently, I came across a simple tutorial on using Biopython, and after thoroughly studying the material, I was inspired to build a few projects that combine these foundational bioinformatics concepts with AI. My goal was to gain hands-on experience while creating something both educational and interactive. (https://www.kaggle.com/code/shtrausslearning/biopython-bioinformatics-basics#8-|-PHYLOGENETIC-ANALYSIS)

The first project in this series is called the "Central Dogma Explorer." It's an interactive educational tool designed to take a gene name, retrieve its DNA sequence, and visually demonstrate the biological processes of transcription and translation, ultimately showing how a functional protein is produced.

To make this more manageable, I divided the project into three core components:

Biopython Integration – I wrote functions such as fetch_gene_sequence(gene_symbol, organism="Homo sapiens") and transcribe_translate_dna(dna_seq) to retrieve and process DNA sequences. These functions fetch gene data, transcribe DNA into mRNA, and translate it into an amino acid sequence.
AI Explanation with an LLM – I incorporated a language model to explain the transcription and translation processes in simple terms. Here's the core function:

def generate_explanation(dna_seq):
    prompt = PromptTemplate(
        input_variables=["sequence"],
        template=(
            "You are an expert biology tutor. Explain the full process of transcription and translation "
            "for this DNA sequence: {sequence}. Your answer should be clear and easy to understand for a first-year biology student."
        )
    )
    chain = LLMChain(llm=llm, prompt=prompt)
    explanation = chain.run(sequence=dna_seq[:500])  # Limit to 500 bases
    return explanation

User Interface with Streamlit – I built a simple, user-friendly interface using Streamlit to display the DNA sequence, the corresponding mRNA transcript, the amino acid sequence, and an AI-generated explanation. Example UI elements include:

st.subheader("1️⃣ DNA Sequence")
st.code(dna_seq[:1000] + ("..." if len(dna_seq) > 1000 else ""), language="text")

st.subheader("2️⃣ mRNA Transcript")
st.code(rna_seq[:1000] + ("..." if len(rna_seq) > 1000 else ""), language="text")

st.subheader("3️⃣ Amino Acid Sequence")
st.code(protein_seq, language="text")

st.subheader("4️⃣ AI-Generated Explanation")
st.markdown(explanation)

I've also created a short tutorial video walking through the application and its features (https://youtu.be/2qi5UPiiS1Q). I'm always open to feedback and would love to hear any suggestions for future bioinformatics projects that combine biology, AI, and interactivity. Thanks for reading!

Here is a link to the code: https://github.com/PranavMunigala/CentralDogmaExplorer.git

Fictional Player Profile Creator

Pranav Munigala — Wed, 18 Jun 2025 16:35:37 +0000

This is the next project in my beginner series, where I explore how to incorporate AI into Python projects by combining it with something I’m passionate about: basketball. My latest project is a player profile creator with a parsed output.

In this app, users click a button named "Create a new prospect". After clicking the button, the app generates a complete, well-structured player profile, including a generated name, position, physical attributes, a list of strengths and weaknesses, and a creative backstory.

Tools I Used:

Streamlit to build the interactive user interface
LangChain to structure the prompt and manage the AI response
OpenAI’s GPT-3.5 Turbo to perform the in-depth player analysis
Python-dotenv to securely load my API key
json parser

Every project in this series helps me build my skills in both coding and AI while keeping it fun by focusing on basketball. I’m looking forward to continuing this series with new features and ideas. As always, feedback is appreciated.

Youtube Video to show how this works: https://youtu.be/sfAUTWXf1mY

Player Announcer Tool

Pranav Munigala — Tue, 17 Jun 2025 19:49:29 +0000

In this app, users can enter the name of any basketball player. After clicking a button, the app produces a high-energy, announcer-style introduction and plays the audio using a realistic AI-generated voice.

Tools I Used:

Streamlit to build the interactive user interface
LangChain to structure the prompt and manage the AI response
OpenAI’s GPT-3.5 Turbo to generate the announcer script
ElevenLabs to convert text into realistic speech
Python-dotenv to securely load my API key

Each project in this series helps me build my skills in both coding and AI while keeping it fun by focusing on basketball. I’m looking forward to continuing this series with new features and ideas. As always, feedback is appreciated.

YouTube video to show how this works:https://www.youtube.com/watch?v=K9AparJ-HOU

"Whos Better at Basketball?" Basic AI Program

Pranav Munigala — Wed, 11 Jun 2025 15:06:55 +0000

In this app, users can enter the names of two basketball players. After clicking a button, the app generates a detailed, side-by-side breakdown of their strengths, weaknesses, and a final comparison explaining who the better player is overall.

Tools I Used:

Streamlit to build the interactive user interface
LangChain to structure the prompt and manage the AI response
OpenAI’s GPT-3.5 Turbo to perform the in-depth player analysis
Python-dotenv to securely load my API key

Youtube Video to show how this works: https://www.youtube.com/watch?v=orScdMnyjhg

Breaking Down Basketball Terms with AI (Beginner Project Series)

Pranav Munigala — Tue, 10 Jun 2025 02:32:38 +0000

Hello,

In my last post, I shared the first project in my beginner series where I’m learning how to incorporate AI into Python coding by connecting it with something I love: basketball. My second project builds on that idea — it's a basketball jargon explainer.

This app allows users to enter a basketball term, and with the click of a button, it returns a beginner-friendly definition generated by AI.

Tools I Used:

Streamlit for creating the interactive web interface
LangChain to structure and manage the language model prompt
OpenAI’s GPT-3.5 Turbo for generating the explanations
Python-dotenv to securely manage my API key

I’m continuing to explore ways to make learning and building with AI both fun and practical. Feedback or suggestions are always welcome. Thanks for following along.

Youtube Video on how it works: https://youtu.be/6mS_SNhxR_4

NBA Random Fact Generator

Pranav Munigala — Mon, 09 Jun 2025 12:30:03 +0000

Hey everyone,

I'm currently learning the basics of AI tools and web app development, and I decided to build something that combines both with one of my favorite interests: basketball.

I created a simple Random NBA Fact Generator using Streamlit and LangChain (with OpenAI’s GPT-3.5 Turbo Instruct model). The app generates a new, true, and concise NBA fact each time you click a button. It also avoids repeating the same fact twice in a row.

How it works:
The app sends a prompt to the LLM:
“Give me one interesting, true, and concise NBA fact. Only return the fact, nothing else.”

I use a temperature of 0.7 to allow for some variation in responses.

Streamlit provides a basic UI, and I use session state to store the previous fact and prevent duplicates.

Why I built this:
I'm exploring how to use Python, AI libraries, and web app frameworks together. Building small, fun projects like this helps reinforce what I'm learning. Since I love basketball, this was a great way to keep things interesting while practicing new tools.

Here is a link to show how the program works: https://youtu.be/7hNdoaspY1A

First 3 projects with AI

Pranav Munigala — Fri, 23 May 2025 13:53:08 +0000

I'm currently a beginner learning how to use AI and improve my coding skills, and recently I built a few small projects that helped me understand how these technologies work. First, I created a simple REACT agent using LangChain and OpenAI that can perform tasks like basic math using tools I defined myself. It was exciting to see how I could connect a language model to actual Python functions and make it respond to user inputs.

Then, I worked on two beginner-friendly Streamlit apps. One is an AI Resume Critiquer, where users upload a PDF or text version of their resume and get detailed feedback generated by GPT. The other is an Image Classifier that uses a pretrained MobileNetV2 model to predict what’s in a given image. Both of these apps helped me learn how to handle file uploads, connect with AI models, and display results cleanly.

These projects may be simple, but they’ve been a great first step into the world of AI and app development. I’m excited to keep learning and building more. I would love to hear some more steps I can take to learn about AI or coding in general. Please feel free to give me recommendations.