GreetingsI have built a pipeline that utilize llama index to read a pdf and ask question

from llama_index.core import VectorStoreIndex, Document

# Assuming you have an existing index
index = VectorStoreIndex.from_documents(
    [Document(text="The sky is purple in Portland, Maine")],
    uri="/tmp/new_dataset",
)

# Insert new nodes
nodes = [node.node for node in response]
index.insert_nodes(nodes)

# Query the index
response = index.query("Your query here")

# Print the response
print(response)

# Print the source nodes
for node in response.source_nodes:
    print(node.get_text())

print(len(index))

index.delete_ref_doc("doc_id_0", delete_from_docstore=True)

# Assuming you have an existing index
index = VectorStoreIndex.from_documents(
    [Document(text="The number that is being searched for is ten.")],
    uri="/tmp/new_dataset",
)

# Query the index
response = index.query("ten")

# Replace the number in the text of the nodes
for node in response.source_nodes:
    node.text = node.text.replace("ten", "your replacement here")

# Delete the old nodes
index.delete_ref_doc("doc_id_0", delete_from_docstore=True)

# Insert the new nodes
index.insert_nodes([node.node for node in response.source_nodes])

index.delete_nodes(["b70f106d-e416-42b2-a9e2-8e7e28f6f9d3"])

index.delete_ref_doc("ref_doc_id_here", delete_from_docstore=True)

from fpdf import FPDF

# Create instance of FPDF class
pdf = FPDF()

# Add a page
pdf.add_page()

# Set font
pdf.set_font("Arial", size = 15)

# Assuming `text_data` is a list of strings from your knowledge base
text_data = ["Text from first document", "Text from second document", "..."]

for line in text_data:
    # Add a cell
    pdf.cell(200, 10, txt = line, ln = True)

# Save the pdf with name .pdf
pdf.output("Your_new_file.pdf")

# Get all nodes
all_nodes = index.get_all_nodes()

# Loop over all nodes and print text
for node in all_nodes:
    print(node.text)

from llama_index.core.retrievers import RecursiveRetriever
from llama_index.core.schema import QueryBundle

# Assuming you have an existing retriever
retriever = RecursiveRetriever(...)

# Create a query bundle
query_bundle = QueryBundle(query="Your query here")

# Retrieve all nodes
all_nodes = retriever.retrieve_all(query_bundle)

# Loop over all nodes and print text
for node in all_nodes:
    print(node.text)

# Assuming you have an existing index
index = VectorStoreIndex(...)

# Get the number of nodes
num_nodes = index.count()

print(f"Number of nodes: {num_nodes}")

from llama_index.core.retrievers import RecursiveRetriever
from llama_index.core.schema import QueryBundle

# Assuming you have an existing retriever
retriever = RecursiveRetriever(...)

# Create a query bundle
query_bundle = QueryBundle(query="Your query here")

# Retrieve all nodes
all_nodes = retriever.retrieve_all(query_bundle)

# Get the number of nodes
num_nodes = len(all_nodes)

print(f"Number of nodes: {num_nodes}")

# Assuming `node` is a node from your index
page_number = node.metadata.get('page_number')
print(f"Page number: {page_number}")

from llama_index.core.node_parser import MarkdownHeaderSplitter

# Assuming `text` is your markdown text
splitter = MarkdownHeaderSplitter()
nodes = splitter.get_nodes_from_documents([text])

# Assuming `index` is your VectorStoreIndex
index.insert_nodes(nodes)

from llama_index.core import VectorStoreIndex
from llama_index.core.node_parser import SentenceSplitter

# Assuming `documents` is your list of documents
splitter = SentenceSplitter(chunk_size=1024)
index = VectorStoreIndex.from_documents(documents, transformations=[splitter])

from llama_index.core.vector_stores import MetadataFilters, MetadataFilter

filters = MetadataFilters(
    filters=[
        MetadataFilter(key="author", value="John Doe"),
    ]
)

retriever = index.as_retriever(filters=filters)

# Assuming you have an existing retriever
retriever = RecursiveRetriever(...)

# Create a query bundle
query_bundle = QueryBundle(query="Your query here")

# Retrieve all nodes
all_nodes = retriever.retrieve_all(query_bundle)

# Sort nodes by order
sorted_nodes = sorted(all_nodes, key=lambda node: node.metadata.get('order'))

# Loop over sorted nodes and print text
for node in sorted_nodes:
    print(node.text)

from llama_index.core.node_parser import SentenceSplitter

# Assuming `text` is your text
splitter = SentenceSplitter()
nodes = splitter.get_nodes_from_documents([text])

# Add sequential identifier to each node
for i, node in enumerate(nodes):
    node.metadata['order'] = i

from llama_index import VectorStoreIndex, SimpleDirectoryReader

# Load documents and build index
documents = SimpleDirectoryReader(
    "../../examples/data/paul_graham"
).load_data()
index = VectorStoreIndex.from_documents(documents)

with open("/content/markdown_files/new_pdf_file/new_pdf_file.md", 'r', encoding='utf-8') as file:
    # Read the content of the file
    content = file.read()

# Split the content into nodes
nodes = parser.split_text(content)

# Convert nodes to text strings
texts = [node.page_content for node in nodes]

# Get nodes from texts
nodes = parser.get_nodes_from_documents(texts)

from llama_index.llms.langchain import LangChainLLM
from llama_index.core import ChatStore
from langchain_openai import ChatOpenAI

# Create a LangChain LLM
llm = LangChainLLM(llm=ChatOpenAI(...))

# Create a ChatStore
chat_store = ChatStore(llm=llm)

# Add a message to the ChatStore
chat_store.add_user_message("Hello, world!")

# Query the ChatStore
response = chat_store.query("What is the meaning of life?")

from llama_index.llms.langchain import LangChainLLM
from llama_index.core import ChatStore
from langchain_openai import ChatOpenAI
from llama_index.core import RAG

# Create a LangChain LLM
llm = LangChainLLM(llm=ChatOpenAI(...))

# Create a ChatStore
chat_store = ChatStore(llm=llm)

# Add a message to the ChatStore
chat_store.add_user_message("Hello, world!")

# Create a RAG
rag = RAG(chat_store=chat_store)

# Query the RAG
response = rag.query("What is the meaning of life?")

from llama_index.llms.langchain import LangChainLLM
from llama_index.core import ChatStore
from langchain_openai import ChatOpenAI

# Create a LangChain LLM
llm = LangChainLLM(llm=ChatOpenAI(...))

# Create a ChatStore
chat_store = ChatStore(llm=llm)

# Add a message to the ChatStore
chat_store.add_user_message("Hello, world!")

# Use LangChain to generate a response
response = llm.complete("What is the meaning of life?")

# Add the response to the ChatStore
chat_store.add_system_message(response)

from llama_index.llms.langchain import LangChainLLM
from llama_index.multi_modal_llms.ollama import OllamaMultiModal
from llama_index.core import RAG

# Create a LangChain LLM
llm = LangChainLLM(llm=OllamaMultiModal(model="llava:13b"))

# Create a RAG
rag = RAG(llm=llm)

# Query the RAG
response = rag.query("What is the meaning of life?")