{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv()\n",
    "\n",
    "os.environ[\"GROQ_API_KEY\"]=os.getenv(\"GROQ_API_KEY\")\n",
    "os.environ[\"OPENAI_API_KEY\"]=os.getenv(\"OPENAI_API_KEY\")\n",
    "os.environ[\"GOOGLE_API_KEY\"] = os.getenv(\"GOOGLE_API_KEY\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from langchain_openai import ChatOpenAI\n",
    "# llm = ChatOpenAI(model=\"gpt-4o\")\n",
    "\n",
    "\n",
    "# from langchain_google_genai import ChatGoogleGenerativeAI\n",
    "# llm = ChatGoogleGenerativeAI(model=\"gemini-1.5-flash\")\n",
    "# llm = ChatGoogleGenerativeAI(model=\"gemini-2.0-flash\")\n",
    "\n",
    "from langchain_groq import ChatGroq\n",
    "llm = ChatGroq(model=\"qwen-2.5-32b\")\n",
    "# llm = ChatGroq(model=\"deepseek-r1-distill-qwen-32b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AIMessage(content='Hello! How can I assist you today?', additional_kwargs={}, response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 30, 'total_tokens': 40, 'completion_time': 0.05, 'prompt_time': 0.004556183, 'queue_time': 0.07078565599999999, 'total_time': 0.054556183}, 'model_name': 'qwen-2.5-32b', 'system_fingerprint': 'fp_c527211fd1', 'finish_reason': 'stop', 'logprobs': None}, id='run-529411a7-693a-4255-ad06-4e5ca0f33fe1-0', usage_metadata={'input_tokens': 30, 'output_tokens': 10, 'total_tokens': 40})"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "llm.invoke(\"Hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### State"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing_extensions import TypedDict\n",
    "\n",
    "\n",
    "class State(TypedDict):\n",
    "    \"\"\"\n",
    "    Represents the structure of the state used in the graph.\n",
    "    \"\"\"\n",
    "\n",
    "    user_message: str\n",
    "    decision: str\n",
    "    yt_url: str\n",
    "    blog_title: str\n",
    "    blog_content: str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Router"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel, Field\n",
    "from typing_extensions import Literal\n",
    "from langchain_core.messages import SystemMessage, HumanMessage\n",
    "\n",
    "\n",
    "class Route(BaseModel):\n",
    "    step: Literal[\"youtube\", \"topic\"] = Field(\n",
    "        None, description=\"The next step in the routing process\"\n",
    "    )\n",
    "\n",
    "\n",
    "def router(state: State):\n",
    "\n",
    "    print(f\"Node Called : router \\n {state}\")\n",
    "\n",
    "    route = llm.with_structured_output(Route)\n",
    "\n",
    "    decision = route.invoke(\n",
    "        [\n",
    "            SystemMessage(content=\"Route the user message to youtube or topic.\"),\n",
    "            HumanMessage(content=state[\"user_message\"]),\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    print(f\"Decision : {decision}\")\n",
    "    if decision.step == \"youtube\":\n",
    "        extract_url = llm.invoke(\n",
    "            [\n",
    "                SystemMessage(\n",
    "                    content=\"Extract youtube url from user message. Only extract youtube link. Don't add any message.\"\n",
    "                ),\n",
    "                HumanMessage(content=state[\"user_message\"]),\n",
    "            ]\n",
    "        )\n",
    "\n",
    "        return {\"yt_url\": extract_url.content, \"decision\": \"yt\"}\n",
    "\n",
    "    return {\"decision\": decision.step}\n",
    "\n",
    "\n",
    "def route_decision(state: State):\n",
    "\n",
    "    print(f\"state : {state}\")\n",
    "    # Return the node name you want to visit next\n",
    "    if state[\"decision\"] == \"youtube\":\n",
    "        return \"youtube\"\n",
    "    elif state[\"decision\"] == \"topic\":\n",
    "        return \"topic\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Youtube Transcript"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from youtube_transcript_api import YouTubeTranscriptApi\n",
    "\n",
    "\n",
    "def yt_transcipt(self, state: State) -> dict:\n",
    "    \"\"\"Fetches transcript from a given YouTube URL\"\"\"\n",
    "\n",
    "    print(f\"Node Called : yt_transcipt\")\n",
    "\n",
    "    video_id = state[\"yt_url\"].replace(\"https://www.youtube.com/watch?v=\", \"\")\n",
    "\n",
    "    try:\n",
    "        transcript = YouTubeTranscriptApi.get_transcript(video_id)\n",
    "        output = \"\\n\".join([x[\"text\"] for x in transcript])\n",
    "        print(\"✅ Transcription fetched successfully.\")\n",
    "    except Exception as e:\n",
    "        print(f\"❌ Error fetching transcript: {e}\")\n",
    "        output = \"\"\n",
    "\n",
    "    return {\"yt_transcription\": output}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Content Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BlogContent(BaseModel):\n",
    "    title: str = Field(description=\"Title of Blog\")\n",
    "    content: str = Field(description=\"\")\n",
    "\n",
    "\n",
    "def generate_blog_content(state: State):\n",
    "\n",
    "    blog_llm = llm.with_structured_output(BlogContent)\n",
    "\n",
    "    blog_content = blog_llm.invoke(\n",
    "        [\n",
    "            SystemMessage(content=\"Generate SEO Friendly Blog of User Topic\"),\n",
    "            HumanMessage(content=f\"User Topic : {state['user_message']}\"),\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    print(f\"### blog_content : {blog_content}\")\n",
    "\n",
    "    return blog_content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from langgraph.graph import START, END, StateGraph\n",
    "\n",
    "from IPython.display import Image, display\n",
    "\n",
    "\n",
    "graph_builder = StateGraph(State)\n",
    "\n",
    "graph_builder.add_node(\"Router\", router)\n",
    "graph_builder.add_node(\"yt_transcipt\", yt_transcipt)\n",
    "graph_builder.add_node(\"generate_blog_content\", generate_blog_content)\n",
    "\n",
    "graph_builder.add_edge(START, \"Router\")\n",
    "graph_builder.add_conditional_edges(\n",
    "    \"Router\",\n",
    "    route_decision,\n",
    "    {\"youtube\": \"yt_transcipt\", \"topic\": \"generate_blog_content\"},\n",
    ")\n",
    "\n",
    "graph_builder.add_edge(\"yt_transcipt\", \"generate_blog_content\")\n",
    "\n",
    "graph_builder.add_edge(\"generate_blog_content\", END)\n",
    "\n",
    "graph = graph_builder.compile()\n",
    "\n",
    "display(Image(graph.get_graph().draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Invoke Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node Called : router \n",
      " {'user_message': 'Langgraph'}\n",
      "Decision : step='topic'\n",
      "state : {'user_message': 'Langgraph', 'decision': 'topic'}\n",
      "### blog_content : title='Mastering Langgraph: A Comprehensive Guide' content=\"Langgraph, a lesser-known but powerful tool in the world of language processing and graph theory, is making waves by offering innovative solutions to complex data analysis problems. In this blog post, we will explore what Langgraph is, how it works, its key features, and how it can be applied in real-world scenarios. \\n\\n### What is Langgraph?\\n\\nLanggraph is an advanced software designed to analyze the structure and relationships within language data, using graph theory principles. By representing language data as a network of nodes and edges, Langgraph helps researchers, data scientists, and developers visualize, analyze, and manipulate linguistic information. This makes it an invaluable tool for understanding the complex patterns and connections inherent in human language.\\n\\n### How Does Langgraph Work?\\n\\nAt its core, Langgraph converts textual data into a graph format, where each node represents a word or phrase, and edges represent relationships or connections between these nodes. These relationships can be based on syntactic, semantic, or even phonetic similarities. Once the data is transformed into a graph, users can apply various graph algorithms and analysis techniques to extract insights and patterns.\\n\\n### Key Features of Langgraph\\n\\n1. **Scalability**: Langgraph is designed to handle large datasets, making it suitable for big data applications.\\n2. **Interactivity**: It offers a user-friendly interface that allows users to interact with the graph data and explore relationships in real-time.\\n3. **Customizability**: Users can define their own graph structures and algorithms, catering to specific research or business needs.\\n4. **Integration**: Langgraph can be easily integrated into existing data processing pipelines and can work with various data formats, including text, audio, and even video.\\n5. **Visualization**: With advanced visualization tools, users can create detailed and interactive visual representations of their data, making it easier to understand complex relationships.\\n\\n### Real-World Applications of Langgraph\\n\\nLanggraph's capabilities make it suitable for a wide range of applications, from academic research to business intelligence. Here are a few examples:\\n\\n- **Academic Research**: Researchers can use Langgraph to uncover patterns in language evolution, comparative linguistics, and more.\\n- **Business Intelligence**: Companies can leverage Langgraph to analyze customer feedback, social media trends, and more to gain insights into consumer behavior.\\n- **Social Media Analysis**: Langgraph can help in understanding the spread of information and the influence of different entities in social media networks.\\n- **Natural Language Processing (NLP)**: Langgraph can play a significant role in NLP tasks such as sentiment analysis, topic modeling, and machine translation.\\n\\n### Conclusion\\n\\nLanggraph stands out as a cutting-edge tool for anyone interested in language data analysis and graph theory. Its unique approach to analyzing language through the lens of graph theory opens up new possibilities for understanding and utilizing linguistic data. Whether you are a researcher, a data scientist, or a business analyst, learning to harness the power of Langgraph can provide you with valuable insights and a competitive edge in your field.\"\n"
     ]
    }
   ],
   "source": [
    "messages = graph.invoke({\"user_message\": \"Langgraph\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}