LLM - Retrieval Augmented Generation

pip install langchain langchain-google-genai

from langchain_google_genai import GoogleGenerativeAI
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

llm = GoogleGenerativeAI(model="gemini-1.5-flash", google_api_key=API_KEY)
prompt = ChatPromptTemplate.from_messages([
    ("system", "Only respond in rhymes"),
    ("user", "{input}")
])
rhyme_chain = prompt | llm | StrOutputParser()
print(rhyme_chain.invoke({"input" : "Tell me about yourself!"}))

A language model, here I stand,
With words at hand, I'll do my best to understand.
To learn and grow, my purpose is to serve,
To answer questions, and to make you observe. 
I'm a tool for knowledge, a friend to you,
With information vast, I'll see you through. 
So tell me your desires, your thoughts, your fears,
And I'll respond with rhymes, through all the years. 

from langchain_google_genai import GoogleGenerativeAIEmbeddings

embedder = GoogleGenerativeAIEmbeddings(model="models/embedding-001", google_api_key=API_KEY)
vector = embedder.embed_query("Hello World!")
vector[:5]

[0.05169878527522087,
 -0.033477481454610825,
 -0.031893402338027954,
 -0.029319265857338905,
 0.019925475120544434]

pip install langchain-community faiss-cpu # 如果使用 GPU 可以安裝 faiss-gpu

from langchain.vectorstores import FAISS

conversation = [
    "[User]  Hello! My name is Beras, and I'm a big blue bear! Can you please tell me about the rocky mountains?",
    "[Agent] The Rocky Mountains are a beautiful and majestic range of mountains that stretch across North America",
    "[Beras] Wow, that sounds amazing! Ive never been to the Rocky Mountains before, but Ive heard many great things about them.",
    "[Agent] I hope you get to visit them someday, Beras! It would be a great adventure for you!"
    "[Beras] Thank you for the suggestion! Ill definitely keep it in mind for the future.",
    "[Agent] In the meantime, you can learn more about the Rocky Mountains by doing some research online or watching documentaries about them."
    "[Beras] I live in the arctic, so I'm not used to the warm climate there. I was just curious, ya know!",
    "[Agent] Absolutely! Lets continue the conversation and explore more about the Rocky Mountains and their significance!"
]

vector_store = FAISS.from_texts(conversation, embedding=embedder)
retriever = vector_store.as_retriever()

print(retriever.invoke("What is your name?"))

[Document(metadata={}, page_content="[User]  Hello! My name is Beras, and I'm a big blue bear! Can you please tell me about the rocky mountains?"), ...]

context_prompt = ChatPromptTemplate.from_template(
    "Answer the question using only the context"
    "\n\nRetrieved Context: {context}"
    "\n\nUser Question: {question}"
    "\nAnswer the user conversationally. User is not aware of context."
)

chain = (
    {'context': vector_store.as_retriever(),
     'question': (lambda x: x)}
    | context_prompt
    | llm
    | StrOutputParser()
)

print(chain.invoke("Where does Beras live?"))

'''
[Output]
Based on the conversation, Beras lives in the arctic!
'''

print(chain.invoke("How far away is Beras from the Rocky Mountains?"))

'''
[Output]
We don't have enough information to know how far Beras is from the Rocky Mountains.
We know Beras lives in the arctic, but we don't know exactly where that is.
'''

pip install langchain-community arxiv pymupdf

from langchain.document_loaders import ArxivLoader

docs = [
    ArxivLoader(query="1706.03762").load(),  # Attention Is All You Need Paper
    ArxivLoader(query="1810.04805").load(),  # BERT Paper
    ArxivLoader(query="2005.11401").load(),  # RAG Paper
    ArxivLoader(query="2205.00445").load(),  # MRKL Paper
    ArxivLoader(query="2310.06825").load(),  # Mistral Paper
    ArxivLoader(query="2306.05685").load(),  # LLM-as-a-Judge Paper
]

import json
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Cut the paper short if references is included.
for doc in docs:
    content = json.dumps(doc[0].page_content)
    if "References" in content:
        doc[0].page_content = content[:content.index("References")]

# Split the documents and also filter out stubs (overly short chunks)
print("Chunking Documents\n")
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000, chunk_overlap=100,
    separators=["\n\n", "\n", ".", ";", ",", " "],
)
docs_chunks = [ text_splitter.split_documents(doc) for doc in docs ]

docstore = FAISS()
for chunk in docs_chunks:
    vecstore = FAISS.from_documents(chunk, embedder)
    docstore.merge_from(vecstore)

from langchain_core.runnables.passthrough import RunnableAssign

initial_msg = (
    "Hello! I am a document chat agent here to help the user!"
    f" I have access to the following documents: {doc_string}\n\nHow can I help you?"
)

chat_prompt = ChatPromptTemplate.from_messages([("system",
    "You are a document chatbot. Help the user as they ask questions about documents."
    " User messaged just asked: {input}\n\n"
    " From this, we have retrieved the following potentially-useful info: "
    " Conversation History Retrieval:\n{history}\n\n"
    " Document Retrieval:\n{context}\n\n"
    " (Answer only from retrieval. Only cite sources that are used. Make your response conversational.)"
), ('user', '{input}')])

stream_chain = chat_prompt | llm | StrOutputParser()
retrieval_chain = (
    {'input' : (lambda x: x)}
    | RunnableAssign({'history' : (lambda x: x['input']) | convstore.as_retriever()})
    | RunnableAssign({'context' : (lambda x: x['input']) | docstore.as_retriever()})
)

def chat_gen(message, history=[], return_buffer=True):
    buffer = ""
    retrieval = retrieval_chain.invoke(message)
    line_buffer = ""

    for token in stream_chain.stream(retrieval):
        buffer += token
        yield buffer if return_buffer else token

    save_memory_and_get_output({'input':  message, 'output': buffer}, convstore)

chat_gen("Tell me about RAG!", return_buffer=False)

'''
[Output]
RAG stands for Retrieval-Augmented Generation. It's a pretty cool technique used in natural language processing (NLP) that combines the strengths of two different types of models:  parametric and non-parametric. 
Think of it like this: The parametric model is like a really smart person who has learned a lot from reading lots of books, but might not know everything. The non-parametric model is like a massive library, full of information but needing someone to find the right books. 
'''

pip install gradio

import gradio as gr

chatbot = gr.Chatbot(value = [[None, initial_msg]])
demo = gr.ChatInterface(chat_gen, chatbot=chatbot).queue()
demo.launch(debug=True, share=True, show_api=False)
demo.close()