LangChain vs LlamaIndex vs Haystack: Framework AI Python

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_core.prompts import PromptTemplate

# 1. Load documents
loader = DirectoryLoader(
    "./docs",
    glob="**/*.txt",
    loader_cls=TextLoader
)
documents = loader.load()

# 2. Split
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = text_splitter.split_documents(documents)

# 3. Embed & Store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4. Create chain
llm = ChatOpenAI(model="gpt-4", temperature=0)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 5. Query
result = qa_chain.invoke({"query": "Apa kebijakan cuti karyawan?"})
print(result["result"])
print("Sumber:", [doc.metadata for doc in result["source_documents"]])

from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

retriever = vectorstore.as_retriever()

prompt = PromptTemplate.from_template("""
Jawab berdasarkan context:
{context}

Pertanyaan: {question}
""")

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

result = rag_chain.invoke("Apa kebijakan cuti?")

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

@tool
def search_docs(query: str) -> str:
    """Cari informasi di database dokumen internal."""
    retriever = vectorstore.as_retriever()
    docs = retriever.invoke(query)
    return "\n".join([d.page_content for d in docs])

@tool
def calculator(expression: str) -> str:
    """Hitung matematika."""
    return str(eval(expression))  # Jangan di production!

llm = ChatOpenAI(model="gpt-4")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Kamu adalah asisten yang helpful. Pakai tools yang tersedia."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_tool_calling_agent(llm, [search_docs, calculator], prompt)
executor = AgentExecutor(agent=agent, tools=[search_docs, calculator], verbose=True)

result = executor.invoke({"input": "Berapa sisa cuti tahunan kalau dihitung 12 - 7?"})

from llama_index.core import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    Settings
)
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# Settings global
Settings.llm = OpenAI(model="gpt-4", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
Settings.chunk_size = 1000
Settings.chunk_overlap = 200

# 1. Load documents (auto-detect format!)
documents = SimpleDirectoryReader("./docs").load_data()
print(f"Loaded {len(documents)} documents")

# 2. Build index
index = VectorStoreIndex.from_documents(documents)

# 3. Create query engine
query_engine = index.as_query_engine(
    similarity_top_k=3,
    response_mode="compact"
)

# 4. Query!
response = query_engine.query("Apa kebijakan cuti karyawan?")
print(response)
print("Sumber:", response.source_nodes)

from llama_index.core import SummaryIndex, VectorStoreIndex

# Load multiple document types
documents = SimpleDirectoryReader(
    input_dir="./docs",
    recursive=True,
    required_exts=[".pdf", ".txt", ".docx"]
).load_data()

# Vector index untuk semantic search
vector_index = VectorStoreIndex.from_documents(documents)

# Summary index untuk overview questions
summary_index = SummaryIndex.from_documents(documents)

# Router — otomatis pilih index yang tepat
from llama_index.core.tools import QueryEngineTool, ToolMetadata

vector_tool = QueryEngineTool(
    query_engine=vector_index.as_query_engine(similarity_top_k=3),
    metadata=ToolMetadata(
        name="vector_search",
        description="Cari informasi spesifik dari dokumen"
    )
)

summary_tool = QueryEngineTool(
    query_engine=summary_index.as_query_engine(),
    metadata=ToolMetadata(
        name="summary_search",
        description="Dapatkan ringkasan/overview dari dokumen"
    )
)

# Router query engine
from llama_index.core.query_engine import RouterQueryEngine

router = RouterQueryEngine(
    query_engine_tools=[vector_tool, summary_tool],
    select_multi=True
)

# LlamaIndex otomatis pilih tool yang tepat
response = router.query("Beri saya ringkasan semua kebijakan perusahaan")

# Save index (biar gak re-process setiap kali)
storage_context = index.storage_context
storage_context.persist(persist_dir="./storage")

# Load index
from llama_index.core import StorageContext, load_index_from_storage

storage_context = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage_context)
query_engine = index.as_query_engine()

from haystack import Pipeline, Document
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack.components.converters import TextFileToDocument
from haystack.components.preprocessors import DocumentSplitter
from haystack.components.embedders import (
    OpenAIDocumentEmbedder,
    OpenAITextEmbedder
)
from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
from haystack.components.generators import OpenAIGenerator
from haystack.components.builders import PromptBuilder

# 1. Document Store
document_store = InMemoryDocumentStore(embedding_similarity_function="cosine")

# 2. Indexing Pipeline
indexing_pipeline = Pipeline()
indexing_pipeline.add_component("converter", TextFileToDocument())
indexing_pipeline.add_component("splitter", DocumentSplitter(
    split_by="word",
    split_length=200,
    split_overlap=50
))
indexing_pipeline.add_component("embedder", OpenAIDocumentEmbedder())
indexing_pipeline.add_component("writer", document_store)

# Connect components
indexing_pipeline.connect("converter.documents", "splitter.documents")
indexing_pipeline.connect("splitter.documents", "embedder.documents")
indexing_pipeline.connect("embedder.documents", "writer.documents")

# Run indexing
from pathlib import Path
indexing_pipeline.run({"converter": {"sources": list(Path("./docs").glob("*.txt"))}})

# 3. Query Pipeline
prompt_template = """
Kamu adalah asisten yang menjawab berdasarkan dokumen.

Context:
{% for doc in documents %}
  {{ doc.content }}
{% endfor %}

Pertanyaan: {{ question }}
Jawaban:
"""

rag_pipeline = Pipeline()
rag_pipeline.add_component("embedder", OpenAITextEmbedder())
rag_pipeline.add_component("retriever", InMemoryEmbeddingRetriever(
    document_store=document_store,
    top_k=3
))
rag_pipeline.add_component("prompt_builder", PromptBuilder(template=prompt_template))
rag_pipeline.add_component("llm", OpenAIGenerator(model="gpt-4"))

# Connect
rag_pipeline.connect("embedder.embedding", "retriever.query_embedding")
rag_pipeline.connect("retriever.documents", "prompt_builder.documents")
rag_pipeline.add_component("prompt_builder", prompt_builder)
rag_pipeline.connect("prompt_builder", "llm")

# 4. Query
result = rag_pipeline.run({
    "embedder": {"text": "Apa kebijakan cuti karyawan?"},
    "prompt_builder": {"question": "Apa kebijakan cuti karyawan?"}
})

print(result["llm"]["replies"][0])

from haystack.components.rankers import TransformersSimilarityRanker

# Tambahin reranker untuk hasil lebih akurat
rag_pipeline.add_component(
    "reranker",
    TransformersSimilarityRanker(model="BAAI/bge-reranker-base")
)

# Wire it up
rag_pipeline.connect("retriever.documents", "reranker.documents")
rag_pipeline.connect("reranker.documents", "prompt_builder.documents")

# Pakai LlamaIndex untuk indexing, LangChain untuk agents
from llama_index.core import VectorStoreIndex
from langchain_openai import ChatOpenAI

# Index with LlamaIndex
index = VectorStoreIndex.from_documents(documents)
retriever = index.as_retriever(similarity_top_k=3)

# Use in LangChain agent
from langchain_core.tools import tool

@tool
def search_docs(query: str) -> str:
    """Search internal docs"""
    results = retriever.retrieve(query)
    return "\n".join([r.node.text for r in results])

# Build agent with LangChain (using LlamaIndex retriever)

test_cases = [
    {"question": "Berapa hari cuti tahunan?", "expected": "12 hari"},
    {"question": "Bagaimana cara klaim BPJS?", "expected": "..."},
    # ... dst
]

for case in test_cases:
    result = query_engine.query(case["question"])
    print(f"Q: {case['question']}")
    print(f"A: {result}")
    print(f"Expected: {case['expected']}")
    print("---")