Chain

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# প্রম্পট টেমপ্লেট তৈরি করুন
prompt_template = PromptTemplate(
    input_variables=["product"],
    template="আমি একটি {product} সম্পর্কে একটি মার্কেটিং বিজ্ঞাপন লিখতে চাই। এটি কেমন হতে পারে?"
)

# LLMChain তৈরি করুন
ad_chain = LLMChain(
    llm=llm,
    prompt=prompt_template,
    verbose=True
)

# চেইন রান করুন
result = ad_chain.run(product="স্মার্ট ওয়াচ")
print(result)

from langchain.chains import SimpleSequentialChain, LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# প্রথম চেইন: প্রোডাক্ট আইডিয়া জেনারেটর
first_prompt = PromptTemplate(
    input_variables=["industry"],
    template="আমি {industry} ইন্ডাস্ট্রিতে একটি নতুন স্টার্টআপ শুরু করতে চাই। একটি ইনোভেটিভ প্রোডাক্ট আইডিয়া সাজেস্ট করুন।"
)
product_chain = LLMChain(llm=llm, prompt=first_prompt)

# দ্বিতীয় চেইন: মার্কেটিং প্ল্যান জেনারেটর
second_prompt = PromptTemplate(
    input_variables=["product_idea"],
    template="নিম্নলিখিত প্রোডাক্ট আইডিয়ার জন্য একটি মার্কেটিং প্ল্যান তৈরি করুন: {product_idea}"
)
marketing_chain = LLMChain(llm=llm, prompt=second_prompt)

# সিকোয়েন্সিয়াল চেইন তৈরি করুন
overall_chain = SimpleSequentialChain(
    chains=[product_chain, marketing_chain],
    verbose=True
)

# চেইন রান করুন
result = overall_chain.run("হেলথকেয়ার")
print(result)

from langchain.chains import SequentialChain, LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# প্রথম চেইন: প্রোডাক্ট ডেসক্রিপশন জেনারেটর
product_prompt = PromptTemplate(
    input_variables=["product_name", "target_audience"],
    template="একটি {product_name} প্রোডাক্টের বিস্তারিত বর্ণনা লিখুন যা {target_audience} টার্গেট করে।"
)
product_chain = LLMChain(
    llm=llm, 
    prompt=product_prompt, 
    output_key="product_description"
)

# দ্বিতীয় চেইন: মার্কেটিং স্লোগান জেনারেটর
slogan_prompt = PromptTemplate(
    input_variables=["product_description"],
    template="নিম্নলিখিত প্রোডাক্ট ডেসক্রিপশন থেকে একটি আকর্ষণীয় মার্কেটিং স্লোগান তৈরি করুন: {product_description}"
)
slogan_chain = LLMChain(
    llm=llm, 
    prompt=slogan_prompt, 
    output_key="slogan"
)

# তৃতীয় চেইন: সোশ্যাল মিডিয়া পোস্ট জেনারেটর
social_prompt = PromptTemplate(
    input_variables=["product_description", "slogan", "platform"],
    template="নিম্নলিখিত প্রোডাক্ট ডেসক্রিপশন এবং স্লোগান ব্যবহার করে {platform} প্ল্যাটফর্মের জন্য একটি সোশ্যাল মিডিয়া পোস্ট লিখুন:\n\nপ্রোডাক্ট: {product_description}\n\nস্লোগান: {slogan}"
)
social_chain = LLMChain(
    llm=llm, 
    prompt=social_prompt, 
    output_key="social_post"
)

# সিকোয়েন্সিয়াল চেইন তৈরি করুন
marketing_chain = SequentialChain(
    chains=[product_chain, slogan_chain, social_chain],
    input_variables=["product_name", "target_audience", "platform"],
    output_variables=["product_description", "slogan", "social_post"],
    verbose=True
)

# চেইন রান করুন
result = marketing_chain({
    "product_name": "স্মার্ট ওয়াটার বটল",
    "target_audience": "ফিটনেস এন্থুসিয়াস্ট",
    "platform": "ইনস্টাগ্রাম"
})

print("প্রোডাক্ট ডেসক্রিপশন:")
print(result["product_description"])
print("\nস্লোগান:")
print(result["slogan"])
print("\nসোশ্যাল মিডিয়া পোস্ট:")
print(result["social_post"])

from langchain.chains.router import MultiPromptChain
from langchain.chains.router.llm_router import LLMRouterChain, RouterOutputParser
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain.chains import LLMChain
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# বিভিন্ন ডোমেইনের জন্য প্রম্পট টেমপ্লেট তৈরি করুন
physics_template = """আপনি একজন ফিজিক্স এক্সপার্ট। নিম্নলিখিত প্রশ্নের উত্তর দিন:
{input}"""

math_template = """আপনি একজন গণিত এক্সপার্ট। নিম্নলিখিত প্রশ্নের উত্তর দিন:
{input}"""

history_template = """আপনি একজন ইতিহাস এক্সপার্ট। নিম্নলিখিত প্রশ্নের উত্তর দিন:
{input}"""

# প্রম্পট ইনফো তৈরি করুন
prompt_infos = [
    {
        "name": "physics",
        "description": "ফিজিক্স সম্পর্কিত প্রশ্ন",
        "prompt_template": physics_template
    },
    {
        "name": "math",
        "description": "গণিত সম্পর্কিত প্রশ্ন",
        "prompt_template": math_template
    },
    {
        "name": "history",
        "description": "ইতিহাস সম্পর্কিত প্রশ্ন",
        "prompt_template": history_template
    }
]

# রাউটার টেমপ্লেট তৈরি করুন
router_template = """নিম্নলিখিত প্রশ্নটি কোন ক্যাটাগরিতে পড়ে তা নির্ধারণ করুন।

প্রশ্ন: {input}

ক্যাটাগরি সিলেক্ট করুন:
{destinations}

ক্যাটাগরি:"""

router_prompt = PromptTemplate(
    template=router_template,
    input_variables=["input"],
    partial_variables={"destinations": ", ".join([f"{p['name']}: {p['description']}" for p in prompt_infos])}
)

# ডেস্টিনেশন চেইন তৈরি করুন
destination_chains = {}
for p_info in prompt_infos:
    prompt = PromptTemplate(template=p_info["prompt_template"], input_variables=["input"])
    chain = LLMChain(llm=llm, prompt=prompt)
    destination_chains[p_info["name"]] = chain

# ডিফল্ট চেইন তৈরি করুন
default_prompt = PromptTemplate(
    template="আপনি একজন সাধারণ সহায়ক। নিম্নলিখিত প্রশ্নের উত্তর দিন:\n{input}",
    input_variables=["input"]
)
default_chain = LLMChain(llm=llm, prompt=default_prompt)

# রাউটার চেইন তৈরি করুন
router_chain = LLMRouterChain.from_llm(llm, router_prompt)

# মাল্টি প্রম্পট চেইন তৈরি করুন
chain = MultiPromptChain(
    router_chain=router_chain,
    destination_chains=destination_chains,
    default_chain=default_chain,
    verbose=True
)

# চেইন রান করুন
print(chain.run("আলোর বেগ কত?"))
print(chain.run("১০০ এবং ২০০ এর যোগফল কত?"))
print(chain.run("বাংলাদেশের স্বাধীনতা যুদ্ধ কবে হয়েছিল?"))

from langchain.chains import RetrievalQA
from langchain_openai import OpenAI
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import TextLoader
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# ডকুমেন্ট লোড করুন
loader = TextLoader("data/bangladesh_history.txt")
documents = loader.load()

# ডকুমেন্ট স্প্লিট করুন
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# এমবেডিং তৈরি করুন
embeddings = OpenAIEmbeddings()

# ভেক্টর স্টোর তৈরি করুন
vectorstore = FAISS.from_documents(texts, embeddings)

# LLM সেটআপ করুন
llm = OpenAI(temperature=0)

# RetrievalQA চেইন তৈরি করুন
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(),
    verbose=True
)

# চেইন রান করুন
query = "বাংলাদেশের স্বাধীনতা যুদ্ধ কবে হয়েছিল এবং কারা নেতৃত্ব দিয়েছিলেন?"
result = qa_chain.run(query)
print(result)

from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import OpenAI
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import TextLoader
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# ডকুমেন্ট লোড করুন
loader = TextLoader("data/bangladesh_history.txt")
documents = loader.load()

# ডকুমেন্ট স্প্লিট করুন
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# এমবেডিং তৈরি করুন
embeddings = OpenAIEmbeddings()

# ভেক্টর স্টোর তৈরি করুন
vectorstore = FAISS.from_documents(texts, embeddings)

# LLM সেটআপ করুন
llm = OpenAI(temperature=0)

# মেমোরি সেটআপ করুন
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# ConversationalRetrievalChain তৈরি করুন
qa_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=vectorstore.as_retriever(),
    memory=memory,
    verbose=True
)

# চেইন রান করুন
result = qa_chain({"question": "বাংলাদেশের স্বাধীনতা যুদ্ধ কবে হয়েছিল?"})
print(result["answer"])

# ফলো-আপ প্রশ্ন
result = qa_chain({"question": "কারা এই যুদ্ধে নেতৃত্ব দিয়েছিলেন?"})
print(result["answer"])

from langchain.chains import SQLDatabaseChain
from langchain_openai import OpenAI
from langchain.utilities import SQLDatabase
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# ডাটাবেস কানেকশন সেটআপ করুন
db = SQLDatabase.from_uri("sqlite:///chinook.db")

# LLM সেটআপ করুন
llm = OpenAI(temperature=0)

# SQLDatabaseChain তৈরি করুন
db_chain = SQLDatabaseChain.from_llm(
    llm=llm,
    database=db,
    verbose=True
)

# চেইন রান করুন
query = "সবচেয়ে বেশি বিক্রি হওয়া ৫টি আর্টিস্ট কারা?"
result = db_chain.run(query)
print(result)

from langchain.chains import APIChain
from langchain_openai import OpenAI
from langchain.prompts.prompt import PromptTemplate
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# LLM সেটআপ করুন
llm = OpenAI(temperature=0)

# API ডকুমেন্টেশন
api_docs = """
BASE URL: https://api.weatherapi.com/v1

API Documentation:
Endpoint: /current.json
Method: GET
Description: Get current weather data
Parameters:
  - key: API key (required)
  - q: Location (required) - Can be city name, latitude/longitude, or IP address
  - aqi: Air quality data (optional) - yes/no

Example:
GET https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London&aqi=no
"""

# APIChain তৈরি করুন
api_chain = APIChain.from_llm_and_api_docs(
    llm=llm,
    api_docs=api_docs,
    headers={"Content-Type": "application/json"},
    verbose=True
)

# চেইন রান করুন
query = "ঢাকার বর্তমান তাপমাত্রা কত?"
result = api_chain.run(query)
print(result)

from langchain.chains import TransformChain, SequentialChain, LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# ট্রান্সফরম ফাংশন ডিফাইন করুন
def extract_keywords(inputs):
    text = inputs["text"]
    # সিম্পল কিওয়ার্ড এক্সট্রাকশন লজিক
    keywords = [word for word in text.split() if len(word) > 5]
    top_keywords = keywords[:5]  # টপ 5 কিওয়ার্ড
    return {"keywords": ", ".join(top_keywords)}

# TransformChain তৈরি করুন
keyword_chain = TransformChain(
    input_variables=["text"],
    output_variables=["keywords"],
    transform=extract_keywords
)

# LLMChain তৈরি করুন
prompt_template = PromptTemplate(
    input_variables=["keywords"],
    template="নিম্নলিখিত কিওয়ার্ডগুলি ব্যবহার করে একটি ছোট গল্প লিখুন: {keywords}"
)
story_chain = LLMChain(
    llm=llm,
    prompt=prompt_template,
    output_key="story"
)

# সিকোয়েন্সিয়াল চেইন তৈরি করুন
overall_chain = SequentialChain(
    chains=[keyword_chain, story_chain],
    input_variables=["text"],
    output_variables=["keywords", "story"],
    verbose=True
)

# চেইন রান করুন
result = overall_chain({
    "text": "বাংলাদেশ একটি সুন্দর দেশ। এখানে প্রাকৃতিক সৌন্দর্য, সমৃদ্ধ সংস্কৃতি এবং ঐতিহাসিক স্থাপত্য রয়েছে। বাংলাদেশের মানুষ অত্যন্ত বন্ধুত্বপূর্ণ এবং আতিথেয়তাপূর্ণ।"
})

print("কিওয়ার্ডস:")
print(result["keywords"])
print("\nগল্প:")
print(result["story"])

from langchain.chains.mapreduce import MapReduceChain
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.document_loaders import TextLoader
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# ডকুমেন্ট লোড করুন
loader = TextLoader("data/bangladesh_economy.txt")
documents = loader.load()

# ডকুমেন্ট স্প্লিট করুন
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# LLM সেটআপ করুন
llm = OpenAI(temperature=0)

# ম্যাপ প্রম্পট টেমপ্লেট
map_template = """নিম্নলিখিত টেক্সট থেকে মূল অর্থনৈতিক তথ্য এবং পরিসংখ্যান বের করুন:

{text}

মূল অর্থনৈতিক তথ্য:"""
map_prompt = PromptTemplate(template=map_template, input_variables=["text"])

# রিডিউস প্রম্পট টেমপ্লেট
reduce_template = """নিম্নলিখিত অর্থনৈতিক তথ্য এবং পরিসংখ্যান থেকে একটি সংক্ষিপ্ত সারাংশ তৈরি করুন:

{text}

সারাংশ:"""
reduce_prompt = PromptTemplate(template=reduce_template, input_variables=["text"])

# MapReduceChain তৈরি করুন
combine_documents_chain = MapReduceChain(
    llm=llm,
    map_prompt=map_prompt,
    reduce_prompt=reduce_prompt,
    verbose=True
)

# চেইন রান করুন
query = "বাংলাদেশের অর্থনীতি সম্পর্কে একটি সংক্ষিপ্ত সারাংশ দিন।"
result = combine_documents_chain.run(texts)
print(result)

from langchain.chains import RetrievalQAWithSourcesChain
from langchain_openai import OpenAI
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import TextLoader
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# ডকুমেন্ট লোড করুন
loader = TextLoader("data/bangladesh_tourism.txt")
documents = loader.load()

# ডকুমেন্ট স্প্লিট করুন
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(documents)

# এমবেডিং তৈরি করুন
embeddings = OpenAIEmbeddings()

# ভেক্টর স্টোর তৈরি করুন
vectorstore = FAISS.from_documents(docs, embeddings)

# LLM সেটআপ করুন
llm = OpenAI(temperature=0)

# RetrievalQAWithSourcesChain তৈরি করুন
chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(),
    verbose=True
)

# চেইন রান করুন
query = "বাংলাদেশে কোন কোন পর্যটন স্পট আছে?"
result = chain({"question": query})
print("উত্তর:", result["answer"])
print("\nসোর্স:", result["sources"])

from langchain.chains.base import Chain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain.chains import LLMChain
from typing import Dict, List, Any
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# কাস্টম চেইন ক্লাস তৈরি করুন
class ContentGeneratorChain(Chain):
    llm: Any
    topic_chain: LLMChain
    outline_chain: LLMChain
    content_chain: LLMChain

    @property
    def input_keys(self) -> List[str]:
        return ["topic"]

    @property
    def output_keys(self) -> List[str]:
        return ["expanded_topic", "outline", "content"]

    def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
        topic = inputs["topic"]

        # টপিক এক্সপ্যান্ড করুন
        expanded_topic = self.topic_chain.run(topic)

        # আউটলাইন তৈরি করুন
        outline = self.outline_chain.run(expanded_topic)

        # কনটেন্ট তৈরি করুন
        content = self.content_chain.run(outline=outline, topic=expanded_topic)

        return {
            "expanded_topic": expanded_topic,
            "outline": outline,
            "content": content
        }

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# টপিক এক্সপ্যান্ডার চেইন
topic_template = """আমি "{topic}" সম্পর্কে একটি ব্লগ পোস্ট লিখতে চাই। এই টপিককে আরও বিস্তারিত এবং আকর্ষণীয় করে বর্ণনা করুন।"""
topic_prompt = PromptTemplate(template=topic_template, input_variables=["topic"])
topic_chain = LLMChain(llm=llm, prompt=topic_prompt)

# আউটলাইন জেনারেটর চেইন
outline_template = """নিম্নলিখিত টপিকের জন্য একটি বিস্তারিত আউটলাইন তৈরি করুন:

{expanded_topic}

আউটলাইন:"""
outline_prompt = PromptTemplate(template=outline_template, input_variables=["expanded_topic"])
outline_chain = LLMChain(llm=llm, prompt=outline_prompt)

# কনটেন্ট জেনারেটর চেইন
content_template = """নিম্নলিখিত টপিক এবং আউটলাইন অনুসরণ করে একটি বিস্তারিত ব্লগ পোস্ট লিখুন:

টপিক: {topic}

আউটলাইন: {outline}

ব্লগ পোস্ট:"""
content_prompt = PromptTemplate(template=content_template, input_variables=["topic", "outline"])
content_chain = LLMChain(llm=llm, prompt=content_prompt)

# কাস্টম চেইন তৈরি করুন
content_generator = ContentGeneratorChain(
    llm=llm,
    topic_chain=topic_chain,
    outline_chain=outline_chain,
    content_chain=content_chain,
    verbose=True
)

# চেইন রান করুন
result = content_generator({"topic": "বাংলাদেশে ইকো-টুরিজম"})

print("এক্সপ্যান্ডেড টপিক:")
print(result["expanded_topic"])
print("\nআউটলাইন:")
print(result["outline"])
print("\nকনটেন্ট:")
print(result["content"])

# ভার্বোস মোড অন করে চেইন তৈরি করুন
chain = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True
)

from langchain.callbacks import StdOutCallbackHandler
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# কলব্যাক হ্যান্ডলার তৈরি করুন
handler = StdOutCallbackHandler()

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# প্রম্পট টেমপ্লেট তৈরি করুন
prompt = PromptTemplate(
    input_variables=["product"],
    template="আমি একটি {product} সম্পর্কে একটি মার্কেটিং বিজ্ঞাপন লিখতে চাই। এটি কেমন হতে পারে?"
)

# চেইন তৈরি করুন
chain = LLMChain(
    llm=llm,
    prompt=prompt,
    callbacks=[handler]
)

# চেইন রান করুন
result = chain.run(product="স্মার্ট ওয়াচ")

from langchain.callbacks.tracers import ConsoleCallbackHandler
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# ট্রেসার তৈরি করুন
tracer = ConsoleCallbackHandler()

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# প্রম্পট টেমপ্লেট তৈরি করুন
prompt = PromptTemplate(
    input_variables=["product"],
    template="আমি একটি {product} সম্পর্কে একটি মার্কেটিং বিজ্ঞাপন লিখতে চাই। এটি কেমন হতে পারে?"
)

# চেইন তৈরি করুন
chain = LLMChain(
    llm=llm,
    prompt=prompt,
    callbacks=[tracer]
)

# চেইন রান করুন
result = chain.run(product="স্মার্ট ওয়াচ")

from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import TextLoader

# ডকুমেন্ট লোড করুন
loader = TextLoader("data/large_document.txt")
documents = loader.load()

# ছোট চাঙ্ক সাইজ ব্যবহার করুন
text_splitter = CharacterTextSplitter(
    chunk_size=500,  # ছোট চাঙ্ক সাইজ
    chunk_overlap=50,  # কম ওভারল্যাপ
    separator="\n"  # ন্যাচারাল সেপারেটর
)
texts = text_splitter.split_documents(documents)

from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache
from langchain_openai import OpenAI
import os

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# ইন-মেমোরি কেশ সেটআপ করুন
set_llm_cache(InMemoryCache())

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# প্রথম কল (কেশ মিস)
response1 = llm.predict("বাংলাদেশের রাজধানী কি?")
print("প্রথম কল:", response1)

# দ্বিতীয় কল (কেশ হিট)
response2 = llm.predict("বাংলাদেশের রাজধানী কি?")
print("দ্বিতীয় কল:", response2)

from langchain.chains import SequentialChain, LLMChain, RetrievalQA, TransformChain
from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import TextLoader
import os
import json

# API কি সেট করুন
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# LLM সেটআপ করুন
llm = OpenAI(temperature=0.7)

# ডকুমেন্ট লোড করুন
loader = TextLoader("data/bangladesh_tourism.txt")
documents = loader.load()

# ডকুমেন্ট স্প্লিট করুন
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# এমবেডিং তৈরি করুন
embeddings = OpenAIEmbeddings()

# ভেক্টর স্টোর তৈরি করুন
vectorstore = FAISS.from_documents(texts, embeddings)

# 1. ইউজার কোয়েরি অ্যানালাইজার চেইন
query_analyzer_prompt = PromptTemplate(
    input_variables=["query"],
    template="""ইউজারের কোয়েরি অ্যানালাইজ করুন এবং নিম্নলিখিত ফরম্যাটে JSON রিটার্ন করুন:

কোয়েরি: {query}

JSON ফরম্যাট:
{{
    "location": "কোয়েরিতে উল্লেখিত লোকেশন (যদি থাকে)",
    "interests": ["ইউজারের আগ্রহের বিষয়গুলি"],
    "duration": "ভ্রমণের সময়কাল (যদি উল্লেখিত থাকে)",
    "budget": "বাজেট (যদি উল্লেখিত থাকে)",
    "search_query": "সার্চ করার জন্য অপটিমাইজড কোয়েরি"
}}
"""
)
query_analyzer_chain = LLMChain(
    llm=llm,
    prompt=query_analyzer_prompt,
    output_key="query_analysis"
)

# 2. JSON পার্সার ট্রান্সফরম চেইন
def parse_json(inputs):
    try:
        analysis = json.loads(inputs["query_analysis"])
        return {
            "location": analysis.get("location", ""),
            "interests": ", ".join(analysis.get("interests", [])),
            "search_query": analysis.get("search_query", inputs["query"])
        }
    except:
        return {
            "location": "",
            "interests": "",
            "search_query": inputs["query"]
        }

json_parser_chain = TransformChain(
    input_variables=["query", "query_analysis"],
    output_variables=["location", "interests", "search_query"],
    transform=parse_json
)

# 3. RetrievalQA চেইন
retrieval_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(),
    output_key="retrieved_info"
)

# 4. ট্রাভেল প্ল্যান জেনারেটর চেইন
travel_plan_prompt = PromptTemplate(
    input_variables=["query", "location", "interests", "retrieved_info"],
    template="""ইউজারের কোয়েরি এবং রিট্রাইভড ইনফরমেশন ব্যবহার করে একটি বিস্তারিত ট্রাভেল প্ল্যান তৈরি করুন।

ইউজারের কোয়েরি: {query}
লোকেশন: {location}
আগ্রহের বিষয়: {interests}

রিট্রাইভড ইনফরমেশন:
{retrieved_info}

ট্রাভেল প্ল্যান:
"""
)
travel_plan_chain = LLMChain(
    llm=llm,
    prompt=travel_plan_prompt,
    output_key="travel_plan"
)

# 5. ফাইনাল রেসপন্স ফরম্যাটার চেইন
formatter_prompt = PromptTemplate(
    input_variables=["travel_plan", "location"],
    template="""নিম্নলিখিত ট্রাভেল প্ল্যানকে সুন্দরভাবে ফরম্যাট করুন, হেডিং, বুলেট পয়েন্ট, এবং সেকশন যোগ করুন:

{travel_plan}

লোকেশন: {location}

ফরম্যাটেড ট্রাভেল প্ল্যান:
"""
)
formatter_chain = LLMChain(
    llm=llm,
    prompt=formatter_prompt,
    output_key="formatted_response"
)

# সব চেইন একত্রিত করুন
travel_planner_chain = SequentialChain(
    chains=[
        query_analyzer_chain,
        json_parser_chain,
        retrieval_chain,
        travel_plan_chain,
        formatter_chain
    ],
    input_variables=["query"],
    output_variables=["query_analysis", "location", "interests", "retrieved_info", "travel_plan", "formatted_response"],
    verbose=True
)

# চেইন রান করুন
query = "আমি ৫ দিনের জন্য কক্সবাজার ভ্রমণ করতে চাই। আমি সমুদ্র সৈকত, প্রাকৃতিক সৌন্দর্য, এবং স্থানীয় খাবার পছন্দ করি। আমার বাজেট ২০,০০০ টাকা।"
result = travel_planner_chain({"query": query})

print("\nফাইনাল রেসপন্স:")
print(result["formatted_response"])