क्वेरी करना और उत्तर बनाना

from langchain_community.vectorstores import InMemoryVectorStore
from langchain_core.documents import Document
from langchain_core.embeddings import Embeddings
from typing import List

# A simple mock for embeddings
class MockEmbeddings(Embeddings):
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        return [[i * 0.1] * 10 for i in range(len(texts))]
    def embed_query(self, text: str) -> List[float]:
        return [0.5] * 10

def main():
    # Create a dummy vector store with some content
    embeddings = MockEmbeddings()
    docs = [
        Document(page_content="The capital of France is Paris.", metadata={"source": "wiki"}),
        Document(page_content="Eiffel Tower is in Paris, France.", metadata={"source": "travel"})
    ]
    vectorstore = InMemoryVectorStore.from_documents(docs, embeddings)

    # Create a retriever from the vector store
    retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
    print("Retriever created successfully!")

if __name__ == "__main__":
    main()

from langchain_community.vectorstores import InMemoryVectorStore
from langchain_core.documents import Document
from langchain_core.embeddings import Embeddings
from typing import List

class MockEmbeddings(Embeddings):
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        return [[i * 0.1] * 10 for i in range(len(texts))]
    def embed_query(self, text: str) -> List[float]:
        return [0.5] * 10

def main():
    embeddings = MockEmbeddings()
    docs = [
        Document(page_content="The capital of France is Paris.", metadata={"source": "wiki"}),
        Document(page_content="Eiffel Tower is in Paris, France.", metadata={"source": "travel"}),
        Document(page_content="London is the capital of the UK.", metadata={"source": "wiki"})
    ]
    vectorstore = InMemoryVectorStore.from_documents(docs, embeddings)
    retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

    user_query = "What is the capital of France?"
    retrieved_docs = retriever.invoke(user_query)

    print(f"Retrieved {len(retrieved_docs)} documents:")
    for doc in retrieved_docs:
        print(f"- {doc.page_content[:50]}...")

if __name__ == "__main__":
    main()

from langchain_core.prompts import ChatPromptTemplate

def main():
    # Define a RAG-specific prompt template
    rag_prompt = ChatPromptTemplate.from_messages([
        ("system", "You are an AI assistant for Q&A. Use the context to answer. If you don't know, say that you don't know."),
        ("human", "Context: {context}\nQuestion: {question}")
    ])

    print("RAG Prompt Template created!")
    # Example of how it formats:
    # print(rag_prompt.format(context="some info", question="a query"))

if __name__ == "__main__":
    main()

from langchain_core.language_models import BaseChatModel
from langchain_core.messages import BaseMessage, AIMessage
from typing import List, Any

# A simple mock LLM
class MockChatLLM(BaseChatModel):
    def invoke(self, input: Any, config: Any = None) -> BaseMessage:
        # Simulate LLM response based on input
        if "Paris" in str(input):
            return AIMessage(content="Paris is the capital of France.")
        elif "London" in str(input):
            return AIMessage(content="London is the capital of the UK.")
        else:
            return AIMessage(content="I don't have enough info to answer.")

    async def ainvoke(self, input: Any, config: Any = None) -> BaseMessage:
        return self.invoke(input, config) # Simple async pass-through

    @property
    def _llm_type(self) -> str:
        return "mock-chat-llm"

def main():
    llm = MockChatLLM()
    print("Mock LLM initialized!")

    # Example invocation (not part of the RAG chain yet)
    response = llm.invoke("Tell me about Paris.")
    print(f"LLM Response: {response.content}")

if __name__ == "__main__":
    main()

from langchain_core.runnables import RunnablePassthrough, RunnableLambda
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.documents import Document
from langchain_community.vectorstores import InMemoryVectorStore
from langchain_core.embeddings import Embeddings
from langchain_core.language_models import BaseChatModel
from langchain_core.messages import BaseMessage, AIMessage
from typing import List, Any

# Mock Embeddings
class MockEmbeddings(Embeddings):
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        return [[i * 0.1] * 10 for i in range(len(texts))]
    def embed_query(self, text: str) -> List[float]:
        return [0.5] * 10

# Mock LLM
class MockChatLLM(BaseChatModel):
    def invoke(self, input: Any, config: Any = None) -> BaseMessage:
        input_str = str(input)
        if "Paris" in input_str and "capital of France" in input_str:
            return AIMessage(content="Based on context, Paris is the capital of France.")
        elif "Eiffel Tower" in input_str and "Paris" in input_str:
            return AIMessage(content="The Eiffel Tower is in Paris, France.")
        else:
            return AIMessage(content="I don't have enough info in the context.")
    async def ainvoke(self, input: Any, config: Any = None) -> BaseMessage:
        return self.invoke(input, config)
    @property
    def _llm_type(self) -> str:
        return "mock-chat-llm"

def main():
    # 1. Setup Retriever
    embeddings = MockEmbeddings()
    docs = [
        Document(page_content="The capital of France is Paris.", metadata={"source": "wiki"}),
        Document(page_content="Eiffel Tower is in Paris, France.", metadata={"source": "travel"})
    ]
    vectorstore = InMemoryVectorStore.from_documents(docs, embeddings)
    retriever = vectorstore.as_retriever(search_kwargs={"k": 1})

    # 2. Setup Prompt
    rag_prompt = ChatPromptTemplate.from_messages([
        ("system", "You are an AI assistant. Use the following context to answer: {context}. If you don't know, say 'I don't know.'"),
        ("human", "Question: {question}")
    ])

    # 3. Setup LLM
    llm = MockChatLLM()

    # 4. Define how to format retrieved documents
    def format_docs(docs: List[Document]) -> str:
        return "\n\n".join(doc.page_content for doc in docs)

    # 5. Build the RAG chain
    rag_chain = (
        {"context": retriever | RunnableLambda(format_docs),
         "question": RunnablePassthrough()}
        | rag_prompt
        | llm
        | StrOutputParser()
    )

    print("RAG chain assembled!")

if __name__ == "__main__":
    main()

from langchain_core.runnables import RunnablePassthrough, RunnableLambda
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.documents import Document
from langchain_community.vectorstores import InMemoryVectorStore
from langchain_core.embeddings import Embeddings
from langchain_core.language_models import BaseChatModel
from langchain_core.messages import BaseMessage, AIMessage
from typing import List, Any

# Mock Embeddings
class MockEmbeddings(Embeddings):
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        return [[i * 0.1] * 10 for i in range(len(texts))]
    def embed_query(self, text: str) -> List[float]:
        return [0.5] * 10

# Mock LLM
class MockChatLLM(BaseChatModel):
    def invoke(self, input: Any, config: Any = None) -> BaseMessage:
        input_str = str(input)
        if "Paris" in input_str and "capital of France" in input_str:
            return AIMessage(content="Based on context, Paris is the capital of France.")
        elif "Eiffel Tower" in input_str and "Paris" in input_str:
            return AIMessage(content="The Eiffel Tower is in Paris, France.")
        else:
            return AIMessage(content="I don't have enough info in the context.")
    async def ainvoke(self, input: Any, config: Any = None) -> BaseMessage:
        return self.invoke(input, config)
    @property
    def _llm_type(self) -> str:
        return "mock-chat-llm"

def main():
    # Setup Retriever
    embeddings = MockEmbeddings()
    docs = [
        Document(page_content="The capital of France is Paris.", metadata={"source": "wiki"}),
        Document(page_content="Eiffel Tower is in Paris, France.", metadata={"source": "travel"})
    ]
    vectorstore = InMemoryVectorStore.from_documents(docs, embeddings)
    retriever = vectorstore.as_retriever(search_kwargs={"k": 1})

    # Setup Prompt
    rag_prompt = ChatPromptTemplate.from_messages([
        ("system", "You are an AI assistant. Use the following context to answer: {context}. If you don't know, say 'I don't know.'"),
        ("human", "Question: {question}")
    ])

    # Setup LLM
    llm = MockChatLLM()

    def format_docs(docs: List[Document]) -> str:
        return "\n\n".join(doc.page_content for doc in docs)

    # Build the RAG chain
    rag_chain = (
        {"context": retriever | RunnableLambda(format_docs),
         "question": RunnablePassthrough()}
        | rag_prompt
        | llm
        | StrOutputParser()
    )

    # Invoke the RAG chain with a query
    query = "Where is the Eiffel Tower?"
    result = rag_chain.invoke(query)
    print(f"Query: {query}")
    print(f"Answer: {result}")

    query_no_context = "What is the capital of Japan?"
    result_no_context = rag_chain.invoke(query_no_context)
    print(f"\nQuery: {query_no_context}")
    print(f"Answer: {result_no_context}")

if __name__ == "__main__":
    main()