from langchain.embeddings import OpenAIEmbeddings

                # Initialize embeddings model
                embeddings = OpenAIEmbeddings()

                # Generate embedding for text
                text = "Machine learning is amazing"
                vector = embeddings.embed_query(text)

                print(len(vector))  # 1536 dimensions
                print(vector[:5])   # [0.023, -0.145, 0.678, 0.234, -0.012]

                # Embed multiple documents at once
                docs = ["doc1", "doc2", "doc3"]
                doc_vectors = embeddings.embed_documents(docs)

# Install: pip install chromadb
        from langchain.vectorstores import Chroma
        from langchain.embeddings import OpenAIEmbeddings

        # 1. Create embeddings model
        embeddings = OpenAIEmbeddings()

        # 2. Sample documents
        docs = [
            "Paris is the capital of France",
            "Python is a programming language",
            "The Eiffel Tower is in Paris",
            "Machine learning uses Python"
        ]

        # 3. Create vector store from documents
        vectorstore = Chroma.from_texts(
            texts=docs,
            embedding=embeddings,
            persist_directory="./chroma_db"  # Save to disk
        )

        # 4. Search for similar documents
        query = "Tell me about France"
        results = vectorstore.similarity_search(query, k=2)

        for doc in results:
            print(doc.page_content)

from langchain.schema import Document

        # Create document with metadata
        doc = Document(
            page_content="Paris is the capital of France",
            metadata={
                "source": "geography.pdf",
                "page": 42,
                "author": "John Smith",
                "date": "2024-01-15",
                "category": "geography"
            }
        )

        # Store in vector DB
        vectorstore = Chroma.from_documents([doc], embeddings)

        # Filter by metadata during search
        results = vectorstore.similarity_search(
            query="capitals",
            filter={"category": "geography"}
        )

from langchain.vectorstores import Chroma

        # Assume vectorstore is already created

        # 1. Basic similarity search (top k)
        results = vectorstore.similarity_search(
            query="What is machine learning?",
            k=3  # Return top 3 most similar
        )

        # 2. Similarity search with scores
        results = vectorstore.similarity_search_with_score(
            query="What is machine learning?",
            k=3
        )
        for doc, score in results:
            print(f"Score: {score:.3f} - {doc.page_content}")

        # 3. MMR (Maximum Marginal Relevance) - diverse results
        results = vectorstore.max_marginal_relevance_search(
            query="machine learning",
            k=3,
            fetch_k=10,  # Fetch 10, return 3 diverse ones
            lambda_mult=0.5  # Balance relevance vs diversity
        )

        # 4. With metadata filtering
        results = vectorstore.similarity_search(
            query="policy updates",
            k=3,
            filter={"year": 2024}

from langchain.retrievers import BM25Retriever, EnsembleRetriever
        from langchain.vectorstores import Chroma

        # 1. Semantic retriever (vector search)
        vectorstore = Chroma.from_documents(docs, embeddings)
        semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

        # 2. Keyword retriever (BM25)
        bm25_retriever = BM25Retriever.from_documents(docs)
        bm25_retriever.k = 3

        # 3. Combine them with weights
        ensemble_retriever = EnsembleRetriever(
            retrievers=[semantic_retriever, bm25_retriever],
            weights=[0.5, 0.5]  # 50% semantic, 50% keyword
        )

        # 4. Use hybrid retriever
        results = ensemble_retriever.get_relevant_documents(
            "What is the company vacation policy?"
        )

        for doc in results:
            print(doc.page_content)

# Install: pip install ragas
        from ragas import evaluate
        from ragas.metrics import (
            faithfulness,
            answer_relevancy,
            context_precision,
            context_recall
        )

        # Your RAG pipeline results
        data = {
            "question": ["What is the vacation policy?"],
            "answer": ["Employees get 15 days PTO annually"],
            "contexts": [["Vacation policy: 15 days...", "PTO accrues..."]],
            "ground_truth": ["The company offers 15 days paid time off"]
        }

        # Evaluate
        result = evaluate(
            data,
            metrics=[faithfulness, answer_relevancy, context_precision, context_recall]
        )

        print(result)

from langchain.document_loaders import PyPDFLoader
        from langchain.text_splitter import RecursiveCharacterTextSplitter
        from langchain.embeddings import OpenAIEmbeddings
        from langchain.vectorstores import Chroma
        from langchain.chains import RetrievalQA
        from langchain.chat_models import ChatOpenAI

        # 1. Load documents
        loader = PyPDFLoader("company_docs.pdf")
        documents = loader.load()

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

        # 3. Create embeddings and store
        embeddings = OpenAIEmbeddings()
        vectorstore = Chroma.from_documents(chunks, embeddings)

        # 4. Create retrieval chain
        qa_chain = RetrievalQA.from_chain_type(
            llm=ChatOpenAI(temperature=0),
            chain_type="stuff",
            retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
        )

        # 5. Ask questions!
        answer = qa_chain.run("What is the vacation policy?")
        print(answer)