Ollama: RAGパイプライン

# RAG: Retrieve relevant docs, then generate answer
docs = retriever.invoke("What is the warranty for headphones?")
answer = llm.invoke(f"Based on: {docs}\nAnswer: What is the warranty?")

from langchain_ollama import OllamaEmbeddings

# Initialize embeddings model
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Embed a single text
vector = embeddings.embed_query("What is the return policy?")
print(f"Dimension: {len(vector)}")  # 768

# Embed multiple texts
vectors = embeddings.embed_documents([
    "Free shipping on orders over $50",
    "30-day return policy for all products",
    "Warranty covers manufacturing defects for 1 year"
])
print(f"Embedded {len(vectors)} documents")

# Execution successful

from langchain_community.document_loaders import TextLoader, PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Load text document
loader = TextLoader("product_faq.txt")
docs = loader.load()
print(f"Loaded {len(docs)} document(s)")

# Split into chunks
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", ". ", " ", ""]
)
chunks = splitter.split_documents(docs)
print(f"Split into {len(chunks)} chunks")
print(f"First chunk preview: {chunks[0].page_content[:100]}...")

# Execution successful

from langchain_ollama import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Prepare documents
documents = [
    "Return policy: 30 days from purchase, items must be in original condition.",
    "Shipping: Free for orders over $50. Standard delivery takes 3-5 business days.",
    "Warranty: All electronics have a 1-year manufacturer warranty.",
    "International shipping: Available to 50+ countries. Import duties may apply.",
    "Refund process: Full refund within 5-7 business days after we receive the return."
]

# Split documents
splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=20)
chunks = splitter.create_documents(documents)

# Create vector store
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Similarity search
results = vectorstore.similarity_search("How do I get a refund?", k=2)
for doc in results:
    print(f"- {doc.page_content}")

# Execution successful

from langchain_ollama import OllamaEmbeddings
from langchain_community.vectorstores import FAISS

embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Create FAISS index
texts = [
    "Product A: Wireless headphones, $89.99, Bluetooth 5.3",
    "Product B: Laptop stand, $34.99, Adjustable height",
    "Product C: USB-C cable, $12.99, 2-meter length"
]
vectorstore = FAISS.from_texts(texts, embeddings)

# Save and load
vectorstore.save_local("./faiss_index")
loaded_vs = FAISS.load_local("./faiss_index", embeddings,
                              allow_dangerous_deserialization=True)

# Search
results = loaded_vs.similarity_search("headphones", k=2)
for doc in results:
    print(doc.page_content)

# Execution successful

from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# Build retriever
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Build RAG chain
llm = ChatOllama(model="qwen2.5", temperature=0.3)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are SupportBot. Answer based ONLY on the following context. "
               "If the answer is not in the context, say 'I don't have that information. "
               "Let me connect you with a human agent.'\n\nContext:\n{context}"),
    ("human", "{question}")
])

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

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

# Ask questions
answer = rag_chain.invoke("What is the return policy?")
print(answer)

# Function defined successfully

# ============================================
# Comprehensive: SupportBot V3 with RAG
# Product knowledge base powered customer service
# ============================================

from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_community.document_loaders import TextLoader
from langchain_community.vectorstores import Chroma
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from pathlib import Path

class SupportBotV3:
    def __init__(self, kb_path: str = "./knowledge_base",
                 model: str = "qwen2.5",
                 embed_model: str = "nomic-embed-text"):
        self.llm = ChatOllama(model=model, temperature=0.3)
        self.embeddings = OllamaEmbeddings(model=embed_model)
        self.kb_path = kb_path
        self.vectorstore = None
        self.rag_chain = None

    def build_knowledge_base(self, doc_dir: str):
        """Load documents and build vector store."""
        docs = []
        for f in Path(doc_dir).glob("*.txt"):
            loader = TextLoader(str(f))
            docs.extend(loader.load())
        for f in Path(doc_dir).glob("*.md"):
            loader = TextLoader(str(f))
            docs.extend(loader.load())

        splitter = RecursiveCharacterTextSplitter(
            chunk_size=500, chunk_overlap=50
        )
        chunks = splitter.split_documents(docs)

        self.vectorstore = Chroma.from_documents(
            documents=chunks,
            embedding=self.embeddings,
            persist_directory=self.kb_path
        )
        print(f"Indexed {len(chunks)} chunks from {len(docs)} documents")

    def setup_rag_chain(self):
        """Build the RAG chain."""
        if not self.vectorstore:
            self.vectorstore = Chroma(
                persist_directory=self.kb_path,
                embedding_function=self.embeddings
            )

        retriever = self.vectorstore.as_retriever(search_kwargs={"k": 3})

        prompt = ChatPromptTemplate.from_messages([
            ("system", (
                "You are SupportBot for GlobalShop e-commerce. "
                "Answer based ONLY on the provided context. "
                "If not in context, say: 'Let me connect you with a human agent.' "
                "Be concise (2-3 sentences).\n\nContext:\n{context}"
            )),
            ("human", "{question}")
        ])

        def format_docs(docs):
            return "\n\n".join(d.page_content for d in docs)

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

    def ask(self, question: str) -> str:
        """Ask a question using RAG."""
        if not self.rag_chain:
            self.setup_rag_chain()
        return self.rag_chain.invoke(question)

# Usage
if __name__ == "__main__":
    bot = SupportBotV3()

    # First time: build knowledge base
    # bot.build_knowledge_base("./docs")

    # Ask questions
    questions = [
        "What is the return policy for electronics?",
        "How long does international shipping take?",
        "Do you offer free returns?",
    ]
    for q in questions:
        answer = bot.ask(q)
        print(f"Q: {q}")
        print(f"A: {answer}\n")