pip install langchain
pip install langchain_community
pip install langchain-chroma
pip show langchain

#!/usr/bin/env python  
# coding=utf-8  
from langchain_core.documents import Document  
  
documents = [  
    Document(  
        page_content="Dogs are great companions, known for their loyalty and friendliness.",  
        metadata={"source": "mammal-pets-doc"},  
    ),  
    Document(  
        page_content="Cats are independent pets that often enjoy their own space.",  
        metadata={"source": "mammal-pets-doc"},  
    ),  
    Document(  
        page_content="Goldfish are popular pets for beginners, requiring relatively simple care.",  
        metadata={"source": "fish-pets-doc"},  
    ),  
    Document(  
        page_content="Parrots are intelligent birds capable of mimicking human speech.",  
        metadata={"source": "bird-pets-doc"},  
    ),  
    Document(  
        page_content="Rabbits are social animals that need plenty of space to hop around.",  
        metadata={"source": "mammal-pets-doc"},  
    ),  
]  
  
# 使用文档创建向量数据库  
from langchain_chroma import Chroma  
from langchain_community.embeddings import OllamaEmbeddings  
oembed = OllamaEmbeddings(base_url="http://localhost:11434", model="nomic-embed-text")  
vectorstore = Chroma.from_documents(documents, embedding=oembed)  
# vectorstore.similarity_search("cat")  
  
# 测试查询文档  
# from langchain_core.runnables import RunnableLambda  
# docs = vectorstore.similarity_search(question)  
# retriever = RunnableLambda(vectorstore.similarity_search).bind(k=1)  # select top result  
# retriever.batch(["cat", "shark"])  
  
retriever = vectorstore.as_retriever(  
    search_type="similarity",  
    search_kwargs={"k": 1},  
)  
  
# 检索问答链  
# 先基于问题的嵌入找到最相关的文档块，然后将这些文档块作为上下文，结合问题一起提交给ollama模型，以获取更加准确的答案  
from langchain_core.prompts import ChatPromptTemplate  
from langchain_core.runnables import RunnablePassthrough  
from langchain_community.llms import Ollama  
message = """  
Answer this question using the provided context only.  
  
{question}  
  
Context:  
{context}  
"""  
prompt = ChatPromptTemplate.from_messages([("human", message)])  
llm = Ollama(model="lm3")  
rag_chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | llm  
response = rag_chain.invoke("tell me about cats")

from langchain.document_loaders import PyMuPDFLoader

# This will load the PDF file
def load_pdf_data(file_path):
    # Creating a PyMuPDFLoader object with file_path
    loader = PyMuPDFLoader(file_path=file_path)
 
    # loading the PDF file
    docs = loader.load()
 
    # returning the loaded document
    return docs

# Responsible for splitting the documents into several chunks
def split_docs(documents, chunk_size=1000, chunk_overlap=20):
 
    # Initializing the RecursiveCharacterTextSplitter with
    # chunk_size and chunk_overlap
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap
    )
 
    # Splitting the documents into chunks
    chunks = text_splitter.split_documents(documents=documents)
 
    # returning the document chunks
    return chunks

# function for loading the embedding model
def load_embedding_model(model_path, normalize_embedding=True):
    return OllamaEmbeddings(base_url="http://localhost:11434", model="nomic-embed-text")
 
 
# Function for creating embeddings using FAISS
def create_embeddings(chunks, embedding_model, storing_path="vectorstore"):
    # Creating the embeddings using FAISS
    vectorstore = Chroma.from_documents(chunks, embedding_model)
 
    # Saving the model in current directory
    vectorstore.save_local(storing_path)
 
    # returning the vectorstore
    return vectorstore

prompt = """
### System:
You are an AI Assistant that follows instructions extreamly well. \
Help as much as you can.
### User:
{prompt}
### Response:
"""

template = """
### System:
You are an respectful and honest assistant. You have to answer the user's \
questions using only the context provided to you. If you don't know the answer, \
just say you don't know. Don't try to make up an answer.
### Context:
{context}
### User:
{question}
### Response:
"""

# Creating the chain for Question Answering
def load_qa_chain(retriever, llm, prompt):
    return RetrievalQA.from_chain_type(
        llm=llm,
        retriever=retriever, # here we are using the vectorstore as a retriever
        chain_type="stuff",
        return_source_documents=True, # including source documents in output
        chain_type_kwargs={'prompt': prompt} # customizing the prompt
    )

# Prettifying the response
def get_response(query, chain):
    # Getting response from chain
    response = chain({'query': query})
 
    # Wrapping the text for better output in Jupyter Notebook
    wrapped_text = textwrap.fill(response['result'], width=100)
    print(wrapped_text)

from lang_funcs import *
from langchain.llms import Ollama
from langchain import PromptTemplate

# Loading orca-mini from Ollama
llm = Ollama(model="orca-mini", temperature=0)
 
# Loading the Embedding Model
embed = load_embedding_model(model_path="all-MiniLM-L6-v2")

# loading and splitting the documents
docs = load_pdf_data(file_path="data/ml_book.pdf")
documents = split_docs(documents=docs)
 
# creating vectorstore
vectorstore = create_embeddings(documents, embed)
 
# converting vectorstore to a retriever
retriever = vectorstore.as_retriever()

# Creating the prompt from the template which we created before
prompt = PromptTemplate.from_template(template)
 
# Creating the chain
chain = load_qa_chain(retriever, llm, prompt)

>>>get_response("What is random forest?", chain)