How to make your own AI chatbot for absolute beginners?

Kush Dhuvad — Tue, 24 Feb 2026 19:02:44 +0000

Have you ever thought of integrating an AI chatbot for your internal systems, where AI has the knowledge of all of your documents, and you can use it to get answers from your own documents instead of getting generic answers? It all starts by making your own AI chatbot using Langchain.

In this article, we'll understand how to make your own AI chatbot that gives generic answers from the internet based on what it's trained on. Later, in the next article, we will learn how to use our own documents as a reference for our AI chatbot.

In this article, I'll show you how to use LangChain and an OpenAI API key to run your own AI chatbot on Streamlit using Python.

First things first, we need to understand the requirements for this project. Create a new folder and create a new file in it called app.py and requirements.txt. Add the following libraries to requirements.txt and run the command below to install all the requirements for the project.

langchain-openai>=0.1.0

langchain-core>=0.1.0

openai>=1.0.0

streamlit>=1.30.0

python-dotenv>=1.0.0

langchain-community>=0.1.0

Before we get started with making the chatbot, we need to understand what Langchain is and how we are going to use it to make our own chatbot.

Langchain

Think of this as the "LEGO" set for AI. It helps us connect different pieces (like prompts and models) together into a "chain."

The core concept of LangChain is the Chain. Imagine a literal chain with different links. Each link performs a specific task.

In your code, the chain looks like this:

chain = prompt | llm | output_parser

Link 1 (Prompt): Takes your raw text ("What is the moon?") and wraps it in instructions ("You are a helpful assistant...").

Link 2 (LLM): Takes that wrapped package and sends it to the AI brain (OpenAI) to get an answer.

Link 3 (Output Parser): Takes the raw, messy data the AI sends back and turns it into clean text for your website.

Why do we need LangChain?

Without LangChain, you would have to write dozens of lines of manual code to:

Connect to the API.
Format the JSON data correctly.
Check for errors if the AI fails.
Remember what was said three sentences ago (Memory).

LangChain reduces all that work into a single line. It allows you to swap out parts easily. If you decide you don't like the "Gemma" model and want to use "GPT-4," you only have to change one word in your code; the rest of the "chain" stays exactly the same.

We will use Langchain here to monitor the API responses from the AI model. For that, go to the website given below and create a new project and generate an API key.

Langchain - LangSmith setup

Once you set up your account, you will see something like this as a response when you search for anything on the AI chatbot that you made.

Let's understand the code now.

1. Understanding required libraries

from langchain_openai import ChatOpenAI #Importing the brain
from langchain_core.prompts import ChatPromptTemplate #Importing brain prompting
from langchain_core.output_parsers import StrOutputParser #Importing output parser
import streamlit as st # Importing Streamlit for UI 
import os 
from dotenv import load_dotenv #Importing keys 

load_dotenv()

2. Importing the essential keys
Make a separate folder called.env and set up your keys over there. We never use API keys in the main code to avoid exposure to secret API keys.

OPENAI_API_KEY=

LANGCHAIN_API_KEY=

LANGCHAIN_PROJECT="Test Project"

How to generate an OpenAI API key?

Go to the website given below, sign up, and you might have to add $5 to your account to get your API key. Once you have the $5 in the account, you can generate a new API key from the website. You can also use Llama models to run your local AI model for free, but then it requires a high-spec, local system, so it might take a long time to process on lower-end systems.

OpenAI API Key - OpenAI API key

Now we'll import the API keys in our code.

os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")  #Importing OpenAI API key 

#Langsmith Tracing

os.environ["LANGCHAIN_TRACING_V2"] = "true" #Enabling tracing to monitor the API response.
os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY") #Importing Langchain API key for tracing

3. Setting up the AI prompt

Here you can decide what kind of AI you want. You can ask it to be a doctor or an engineer, to tailor your responses.

prompt=ChatPromptTemplate.from_messages([

    ("system","You are a helpful assistant that helps answer questions about the world."),

    ("human","Question:{question}")

])

4. Setting up Streamlit UI for the web

st.title("Chatbot with Langchain and Streamlit")
input_text=st.text_input("Ask a question about the world:")

5. Calling the OpenAI model and setting up the chain

llm=ChatOpenAI(model="gpt-3.5-turbo") #We are using the OpenAI model GPT-3.5 Turbo since it is cost-effective 

output_parser=StrOutputParser() #we are parsing the output to view on the web. 

chain=prompt | llm | output_parser #Setting up the chain so that the prompt goes to the LLM and then we get the output response

6. Invoking the response

When the user presses Enter, we invoke the chain so that the user question goes to the LLM and outputs a response.

if input_text:

    st.write(chain.invoke({"question":input_text}))

This eventually gives you a final AI chatbot where you can ask it any questions, and it will give you a response using the GPT-3.5 Turbo AI model as shown below

Use the command below in your terminal to run the AI chatbot.

streamlit run app.py

Try changing the System Prompt from 'helpful assistant' to 'grumpy pirate' and see how the personality shifts!

If you have any questions, I'm attaching the GitHub link to the final code. Feel free to refer to it for any questions.

Github Link - AI Chatbot

Buy Me a Coffee - Buy Me a Coffee

The $500 Million Security Gap: Bank of Ireland UK’s Critical Failure

Kush Dhuvad — Fri, 20 Feb 2026 21:20:52 +0000

The Institutional Failure of "Confirmation of Payee"

On February 20, 2026, Bank of Ireland UK (BOIUK) issued a formal apology for its failure to implement "Confirmation of Payee" (CoP) send requests. While seemingly a back-office technicality, this delay represents a critical vulnerability in the UK’s banking infrastructure. CoP is designed to cross-reference account names with account numbers to prevent Authorised Push Payment (APP) fraud—a category of crime that saw UK consumers lose £459.7 million in the most recent annual reporting cycle.

The $500 Million Security Gap

The "So What?" of the BOIUK delay is simple: friction saves money. The UK Payment Systems Regulator (PSR) originally mandated CoP for Group 1 banks by 2020, yet mid-tier institutions continue to struggle with the rollout. For BOIUK customers, the lack of a CoP feature means they are significantly more exposed to "malicious redirection" scams. According to UK Finance data, 77% of APP fraud cases originate on social media, but the final point of failure is always the bank transfer. By missing the implementation window, BOIUK is effectively leaving the door unlocked in a neighborhood where 1 in 4 adults has been targeted by a financial scam.

A Regulatory 6-3 Split in Priority

The delay highlights a growing divide between institutional capability and regulatory demands. The PSR has the power to fine banks up to 10% of their annual turnover for systemic failures in payment security. BOIUK’s apology is a preemptive strike against potential litigation, but it does little to address the competitive disadvantage. While Tier 1 banks like Barclays and HSBC have maintained CoP functionality for over five years, BOIUK’s delay places them in a high-risk bracket for "mule" account activity, which cost the UK banking sector an estimated £1.2 billion in total fraud losses last year.

The Friction-Security Paradox

The banking sector is currently caught in a paradox: customers demand instant transactions, but security requires intentional friction. The BOIUK failure suggests that the technical debt within mid-sized legacy systems is higher than anticipated. When a bank fails to verify a recipient's identity, the liability often shifts. Under new PSR rules, banks are generally required to reimburse victims of APP fraud up to a £415,000 cap per claim, unless "gross negligence" is proven. By failing to provide CoP, BOIUK isn't just failing its customers; it is increasing its own balance sheet liability in a market where fraud costs are rising at a 5% compound annual growth rate.

The Bottom Line

Bank of Ireland UK’s apology is the sound of a legacy institution hitting a technical wall. In a financial ecosystem where 92% of UK adults use mobile banking, the inability to verify a payee in real-time is no longer an "oversight"—it is a structural liability. As the PSR moves toward even stricter reimbursement mandates, the cost of being "sorry" will soon be outweighed by the cost of the fines.

DEV Community: Kush Dhuvad