06_essay_writer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b570553e-83a6-48cd-bb94-daa2d6179bcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pygraphviz in /home/abram/anaconda3/lib/python3.12/site-packages (1.14)\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "!{sys.executable} -m pip install pygraphviz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "73db0783-a294-498c-baaf-46f2d13ea48e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from dotenv import load_dotenv\n",
    "\n",
    "_ = load_dotenv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "30faaa47-d0d5-48a8-a707-c37dda1f8b56",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import StateGraph, END\n",
    "from typing import TypedDict, Annotated, List\n",
    "import operator\n",
    "import sqlite3\n",
    "from langgraph.checkpoint.sqlite import SqliteSaver\n",
    "from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage, AIMessage, ChatMessage\n",
    "\n",
    "\n",
    "db_path = \"checkpoints.db\"\n",
    "conn = sqlite3.connect(db_path, check_same_thread=False)\n",
    "memory = SqliteSaver(conn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f89bedfe-92aa-4368-a7e6-1a708f212e87",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AgentState(TypedDict):\n",
    "    task: str\n",
    "    plan: str\n",
    "    draft: str\n",
    "    critique: str\n",
    "    content: List[str]\n",
    "    revision_number: int\n",
    "    max_revisions: int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c00fe486-3526-4dfc-a9f4-f031b8ef683f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "\n",
    "model = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "de68fea9-6289-45a1-ac9d-e7def5150ac7",
   "metadata": {},
   "outputs": [],
   "source": [
    "PLAN_PROMPT = \"\"\"You are an expert writer tasked with writing a high level outline of an essay. \\\n",
    "Write such an outline for the user provided topic. Give an outline of the essay along with any relevant notes \\\n",
    "or instructions for the sections.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9ccbda4a-d6b7-4c9f-8610-106f1de445df",
   "metadata": {},
   "outputs": [],
   "source": [
    "WRITER_PROMPT = \"\"\"You are an essay assistant tasked with writing excellent 5-paragraph essays.\\\n",
    "Generate the best essay possible for the user's request and the initial outline. \\\n",
    "If the user provides critique, respond with a revised version of your previous attempts. \\\n",
    "Utilize all the information below as needed: \n",
    "\n",
    "------\n",
    "\n",
    "{content}\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a4ed509e-7aad-4b91-9688-25fce05bd290",
   "metadata": {},
   "outputs": [],
   "source": [
    "REFLECTION_PROMPT = \"\"\"You are a teacher grading an essay submission. \\\n",
    "Generate critique and recommendations for the user's submission. \\\n",
    "Provide detailed recommendations, including requests for length, depth, style, etc.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f546e991-b6be-4086-87cc-e2c642a74ee3",
   "metadata": {},
   "outputs": [],
   "source": [
    "RESEARCH_PLAN_PROMPT = \"\"\"You are a researcher charged with providing information that can \\\n",
    "be used when writing the following essay. Generate a list of search queries that will gather \\\n",
    "any relevant information. Only generate 3 queries max.\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "00b80034-6b44-49fc-90eb-b7d19de20b9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "RESEARCH_CRITIQUE_PROMPT = \"\"\"You are a researcher charged with providing information that can \\\n",
    "be used when making any requested revisions (as outlined below). \\\n",
    "Generate a list of search queries that will gather any relevant information. Only generate 3 queries max.\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8b799336-03f5-4870-b8d0-6c024805b133",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel\n",
    "\n",
    "\n",
    "class Queries(BaseModel):\n",
    "    queries: List[str]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "78b9bfd9-ed55-441e-b17a-854547d7036e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tavily import TavilyClient\n",
    "import os\n",
    "\n",
    "\n",
    "tavily = TavilyClient(api_key=os.environ[\"TAVILY_API_KEY\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c2673408-7101-4e21-905b-661f4e96cd3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plan_node(state: AgentState):\n",
    "    messages = [\n",
    "        SystemMessage(content=PLAN_PROMPT), \n",
    "        HumanMessage(content=state['task'])\n",
    "    ]\n",
    "    response = model.invoke(messages)\n",
    "    return {\"plan\": response.content}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4f9e4074-6f05-4a80-9107-82f7ddb4a2ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def research_plan_node(state: AgentState):\n",
    "    queries = model.with_structured_output(Queries).invoke([\n",
    "        SystemMessage(content=RESEARCH_PLAN_PROMPT),\n",
    "        HumanMessage(content=state['task'])\n",
    "    ])\n",
    "    content = state.get('content') or []\n",
    "    for q in queries.queries:\n",
    "        response = tavily.search(query=q, max_results=2)\n",
    "        for r in response['results']:\n",
    "            content.append(r['content'])\n",
    "    return {\"content\": content}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "aaec9cab-361e-4912-badc-352d09e274d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generation_node(state: AgentState):\n",
    "    content = \"\\n\\n\".join(state['content'] or [])\n",
    "    user_message = HumanMessage(\n",
    "        content=f\"{state['task']}\\n\\nHere is my plan:\\n\\n{state['plan']}\")\n",
    "    messages = [\n",
    "        SystemMessage(\n",
    "            content=WRITER_PROMPT.format(content=content)\n",
    "        ),\n",
    "        user_message\n",
    "        ]\n",
    "    response = model.invoke(messages)\n",
    "    return {\n",
    "        \"draft\": response.content, \n",
    "        \"revision_number\": state.get(\"revision_number\", 1) + 1\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "69d1c27a-cb4b-4299-b965-7a626c96001f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reflection_node(state: AgentState):\n",
    "    messages = [\n",
    "        SystemMessage(content=REFLECTION_PROMPT),\n",
    "        HumanMessage(content=state['draft'])\n",
    "    ]\n",
    "    response = model.invoke(messages)\n",
    "    return {\"critique\": response.content}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4512247e-4068-457f-ae07-aff95ef6327b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def research_critique_node(state: AgentState):\n",
    "    queries = model.with_structured_output(Queries).invoke([\n",
    "        SystemMessage(content=RESEARCH_CRITIQUE_PROMPT),\n",
    "        HumanMessage(content=state['critique'])\n",
    "    ])\n",
    "    content = state.get('content') or []\n",
    "    for q in queries.queries:\n",
    "        response = tavily.search(query=q, max_results=2)\n",
    "        for r in response['results']:\n",
    "            content.append(r['content'])\n",
    "    return {\"content\": content}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bb715729-8a84-41ae-8556-d969c4b4718f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def should_continue(state):\n",
    "    if state[\"revision_number\"] > state[\"max_revisions\"]:\n",
    "        return END\n",
    "    return \"reflect\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "35ba4e12-e43e-4af3-8b83-089c5a813f43",
   "metadata": {},
   "outputs": [],
   "source": [
    "builder = StateGraph(AgentState)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d0b72dd9-0de0-4a49-8d6f-e8d2ae4270e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<langgraph.graph.state.StateGraph at 0x7cbb08d3acc0>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.add_node(\"planner\", plan_node)\n",
    "builder.add_node(\"generate\", generation_node)\n",
    "builder.add_node(\"reflect\", reflection_node)\n",
    "builder.add_node(\"research_plan\", research_plan_node)\n",
    "builder.add_node(\"research_critique\", research_critique_node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3df003ca-7210-4f8f-b9ca-79abc9a26b9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<langgraph.graph.state.StateGraph at 0x7cbb08d3acc0>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.set_entry_point(\"planner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8e21d3a6-3861-4117-83ea-8be4812538ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<langgraph.graph.state.StateGraph at 0x7cbb08d3acc0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.add_conditional_edges(\n",
    "    \"generate\", \n",
    "    should_continue, \n",
    "    {END: END, \"reflect\": \"reflect\"}\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1b751e85-647b-4c6c-9b9a-652c008a6f56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<langgraph.graph.state.StateGraph at 0x7cbb08d3acc0>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.add_edge(\"planner\", \"research_plan\")\n",
    "builder.add_edge(\"research_plan\", \"generate\")\n",
    "\n",
    "builder.add_edge(\"reflect\", \"research_critique\")\n",
    "builder.add_edge(\"research_critique\", \"generate\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c3ef44aa-ff93-4925-8271-9463f546e42c",
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = builder.compile(checkpointer=memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "12f49346-daf4-42b0-885c-4a09a0df2a9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "\n",
    "# Image(graph.get_graph().draw_png())\n",
    "# raises the following error:\n",
    "# ImportError: Install pygraphviz to draw graphs: `pip install pygraphviz`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "03e1dce0-9900-45e2-8494-4e3705e83b2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'planner': {'plan': '### Essay Outline: The Difference Between LangChain and LangSmith\\n\\n#### I. Introduction\\n   A. Definition of LangChain and LangSmith\\n      1. Brief overview of what each tool is designed for\\n      2. Importance of understanding the differences in the context of AI and language processing\\n   B. Purpose of the essay\\n      1. To compare and contrast LangChain and LangSmith\\n      2. To provide insights into their respective use cases and functionalities\\n\\n#### II. Overview of LangChain\\n   A. Description of LangChain\\n      1. Purpose and primary functions\\n      2. Key features and capabilities\\n   B. Use cases\\n      1. Examples of applications in AI and language processing\\n      2. Industries or sectors that benefit from LangChain\\n\\n#### III. Overview of LangSmith\\n   A. Description of LangSmith\\n      1. Purpose and primary functions\\n      2. Key features and capabilities\\n   B. Use cases\\n      1. Examples of applications in AI and language processing\\n      2. Industries or sectors that benefit from LangSmith\\n\\n#### IV. Comparative Analysis\\n   A. Key Differences\\n      1. Functional differences\\n         a. Specific features unique to LangChain\\n         b. Specific features unique to LangSmith\\n      2. Target audience and user base\\n   B. Similarities\\n      1. Common goals in language processing\\n      2. Overlapping functionalities\\n\\n#### V. Advantages and Disadvantages\\n   A. Advantages of LangChain\\n      1. Strengths in specific applications\\n      2. User feedback and community support\\n   B. Advantages of LangSmith\\n      1. Strengths in specific applications\\n      2. User feedback and community support\\n   C. Limitations of each tool\\n      1. Potential drawbacks or challenges faced by users\\n\\n#### VI. Conclusion\\n   A. Summary of key points discussed\\n   B. Final thoughts on choosing between LangChain and LangSmith\\n      1. Recommendations based on specific needs or use cases\\n      2. Future trends in language processing tools\\n\\n### Notes/Instructions:\\n- Ensure that each section is well-researched and includes relevant examples to illustrate points.\\n- Use clear and concise language to make complex concepts accessible to a broad audience.\\n- Consider including visuals or charts in the comparative analysis section to enhance understanding.\\n- Cite sources where necessary to support claims and provide credibility to the information presented.'}}\n",
      "{'research_plan': {'content': ['Here’s the deal: LangChain is like building the entire car, while LangSmith is your diagnostic tool to ensure that car runs smoothly. When it comes to practical application, I always say: “Show, don’t tell.” I’ve used both LangChain and LangSmith extensively, and I’ve found that they complement each other beautifully when you’re building and fine-tuning LLM-based workflows. Having spent countless hours building and debugging LLM-based systems, I’ve learned that using LangChain and LangSmith effectively requires a few smart strategies. I often use LangChain to build my pipelines and LangSmith to monitor and debug them. Start with LangChain to build your pipeline, and then bring in LangSmith to ensure it performs as expected.', 'If you’re responsible for ensuring your AI models work in production, or you need to frequently debug and monitor your pipelines, Langsmith is your go-to tool. In short, while Langchain excels at managing and scaling model workflows, Langsmith is designed for those times when you need deep visibility and control over large, complex AI systems in production. But if you’re managing a complex AI pipeline with multiple models that need debugging and orchestrating, Langsmith’s capabilities become essential. If you’re debugging complex AI models or managing large-scale workflows with multiple moving parts, Langsmith’s advanced debugging and orchestration features will be indispensable. Additionally, if you’re working on cross-platform model deployments — say, running models on-prem and in the cloud simultaneously — Langsmith offers better orchestration and monitoring tools to handle the complexity.', 'LangChain and LangSmith are two complementary tools that cater to different stages and requirements of LLM development. LangChain is ideal for early-stage prototyping and small-scale applications, while LangSmith is better suited for large-scale, production-ready applications that require advanced debugging, testing, and monitoring capabilities', 'Here’s the deal: LangChain is like building the entire car, while LangSmith is your diagnostic tool to ensure that car runs smoothly. When it comes to practical application, I always say: “Show, don’t tell.” I’ve used both LangChain and LangSmith extensively, and I’ve found that they complement each other beautifully when you’re building and fine-tuning LLM-based workflows. Having spent countless hours building and debugging LLM-based systems, I’ve learned that using LangChain and LangSmith effectively requires a few smart strategies. I often use LangChain to build my pipelines and LangSmith to monitor and debug them. Start with LangChain to build your pipeline, and then bring in LangSmith to ensure it performs as expected.', 'LangSmith is a monitoring and testing tool for LLM applications in production. It helps developers ensure their systems are efficient, reliable, and cost-effective. Key Features:', 'LangChain and LangSmith are two complementary tools that cater to different stages and requirements of LLM development. LangChain is ideal for early-stage prototyping and small-scale applications, while LangSmith is better suited for large-scale, production-ready applications that require advanced debugging, testing, and monitoring capabilities.']}}\n",
      "{'generate': {'draft': \"### The Difference Between LangChain and LangSmith\\n\\n#### I. Introduction\\nIn the rapidly evolving landscape of artificial intelligence and language processing, tools like LangChain and LangSmith have emerged as essential components for developers and organizations. LangChain is primarily designed for building and managing language model workflows, while LangSmith serves as a diagnostic tool to monitor and debug these workflows. Understanding the differences between these two tools is crucial for developers looking to optimize their AI applications. This essay aims to compare and contrast LangChain and LangSmith, providing insights into their respective use cases and functionalities.\\n\\n#### II. Overview of LangChain\\nLangChain is a powerful framework that facilitates the development of language model applications. Its primary function is to streamline the process of building and managing pipelines that integrate various language models. Key features of LangChain include its modular architecture, which allows developers to easily customize and extend functionalities, and its support for multiple model types, enabling flexibility in application design. LangChain is particularly beneficial for early-stage prototyping and small-scale applications, making it a popular choice among startups and individual developers. Industries such as education, content creation, and customer service have successfully leveraged LangChain to enhance their AI-driven solutions.\\n\\n#### III. Overview of LangSmith\\nIn contrast, LangSmith is a specialized monitoring and testing tool designed for LLM applications in production. Its primary purpose is to ensure that AI systems operate efficiently, reliably, and cost-effectively. LangSmith offers advanced debugging capabilities, real-time monitoring, and orchestration features that are essential for managing complex AI workflows. This tool is particularly valuable for organizations that deploy large-scale applications requiring constant oversight and optimization. Industries such as finance, healthcare, and e-commerce benefit from LangSmith's ability to provide deep visibility and control over their AI systems, ensuring that they meet performance standards and user expectations.\\n\\n#### IV. Comparative Analysis\\nThe key differences between LangChain and LangSmith lie in their functionalities and target audiences. LangChain excels in building and scaling model workflows, making it ideal for developers focused on creating new applications. Its unique features include a user-friendly interface for pipeline construction and extensive community support for troubleshooting. On the other hand, LangSmith's strengths lie in its advanced debugging and monitoring capabilities, which are crucial for teams managing complex AI systems in production. While both tools share common goals in language processing, such as enhancing model performance and user experience, they cater to different stages of the development lifecycle.\\n\\n#### V. Advantages and Disadvantages\\nLangChain offers several advantages, including its ease of use for prototyping and a strong community that provides valuable resources and support. However, it may lack the advanced monitoring features necessary for large-scale applications. Conversely, LangSmith's strengths lie in its robust debugging and orchestration tools, making it indispensable for production environments. Nevertheless, its complexity may pose a challenge for users who are new to AI development. Both tools have limitations; LangChain may not be suitable for extensive debugging, while LangSmith may be overkill for simple applications.\\n\\n#### VI. Conclusion\\nIn summary, LangChain and LangSmith serve distinct yet complementary roles in the realm of AI and language processing. LangChain is ideal for developers looking to build and prototype applications, while LangSmith is essential for those managing complex, production-ready systems. When choosing between the two, developers should consider their specific needs and use cases. As the field of language processing continues to evolve, both tools are likely to adapt and grow, offering even more capabilities to meet the demands of the industry.\", 'revision_number': 2}}\n",
      "{'reflect': {'critique': '### Critique and Recommendations\\n\\nYour essay provides a clear and structured comparison between LangChain and LangSmith, effectively outlining their functionalities, target audiences, and advantages and disadvantages. However, there are several areas where you could enhance the depth, clarity, and overall impact of your submission. Below are detailed recommendations:\\n\\n#### 1. **Length and Depth**\\n- **Recommendation**: While the essay is well-structured, consider expanding on certain sections to provide more depth. For instance, you could include specific examples or case studies of how organizations have successfully implemented LangChain and LangSmith. This would not only enrich your analysis but also provide practical insights for readers.\\n- **Request**: Aim for a length of 1,200-1,500 words to allow for a more comprehensive exploration of each tool, including potential future developments in the field.\\n\\n#### 2. **Introduction**\\n- **Critique**: The introduction sets the stage well, but it could benefit from a more engaging hook to draw the reader in. \\n- **Recommendation**: Start with a compelling statistic or a brief anecdote about the growing importance of AI in various industries. This will help to contextualize the discussion and emphasize the relevance of the tools being compared.\\n\\n#### 3. **Comparative Analysis**\\n- **Critique**: The comparative analysis section is informative but could be more nuanced. \\n- **Recommendation**: Consider adding a table or a visual aid that summarizes the key differences and similarities between LangChain and LangSmith. This would provide a quick reference for readers and enhance the clarity of your comparison.\\n\\n#### 4. **Advantages and Disadvantages**\\n- **Critique**: While you mention the advantages and disadvantages of both tools, the discussion feels somewhat surface-level.\\n- **Recommendation**: Delve deeper into the implications of these advantages and disadvantages. For example, discuss how the ease of use of LangChain can lead to faster prototyping and innovation, while the complexity of LangSmith might necessitate additional training or resources for teams.\\n\\n#### 5. **Conclusion**\\n- **Critique**: The conclusion effectively summarizes the main points but could be more forward-looking.\\n- **Recommendation**: Discuss potential future trends in AI and language processing that could impact the development of tools like LangChain and LangSmith. This would provide a more dynamic closing and encourage readers to think about the evolving landscape of AI.\\n\\n#### 6. **Style and Tone**\\n- **Critique**: The tone is generally appropriate for an academic essay, but it could be more engaging.\\n- **Recommendation**: Use more varied sentence structures and incorporate rhetorical questions to provoke thought. For example, you might ask, \"As AI continues to evolve, how will tools like LangChain and LangSmith adapt to meet new challenges?\"\\n\\n#### 7. **Citations and References**\\n- **Recommendation**: If you have used any external sources or data, ensure that you include citations in a consistent format (e.g., APA, MLA). This will lend credibility to your arguments and allow readers to explore the topic further.\\n\\n### Final Thoughts\\nOverall, your essay is a solid foundation for discussing LangChain and LangSmith. By incorporating these recommendations, you can enhance the depth, clarity, and engagement of your writing. I look forward to seeing your revised submission!'}}\n",
      "{'research_critique': {'content': ['Here’s the deal: LangChain is like building the entire car, while LangSmith is your diagnostic tool to ensure that car runs smoothly. When it comes to practical application, I always say: “Show, don’t tell.” I’ve used both LangChain and LangSmith extensively, and I’ve found that they complement each other beautifully when you’re building and fine-tuning LLM-based workflows. Having spent countless hours building and debugging LLM-based systems, I’ve learned that using LangChain and LangSmith effectively requires a few smart strategies. I often use LangChain to build my pipelines and LangSmith to monitor and debug them. Start with LangChain to build your pipeline, and then bring in LangSmith to ensure it performs as expected.', 'If you’re responsible for ensuring your AI models work in production, or you need to frequently debug and monitor your pipelines, Langsmith is your go-to tool. In short, while Langchain excels at managing and scaling model workflows, Langsmith is designed for those times when you need deep visibility and control over large, complex AI systems in production. But if you’re managing a complex AI pipeline with multiple models that need debugging and orchestrating, Langsmith’s capabilities become essential. If you’re debugging complex AI models or managing large-scale workflows with multiple moving parts, Langsmith’s advanced debugging and orchestration features will be indispensable. Additionally, if you’re working on cross-platform model deployments — say, running models on-prem and in the cloud simultaneously — Langsmith offers better orchestration and monitoring tools to handle the complexity.', 'LangChain and LangSmith are two complementary tools that cater to different stages and requirements of LLM development. LangChain is ideal for early-stage prototyping and small-scale applications, while LangSmith is better suited for large-scale, production-ready applications that require advanced debugging, testing, and monitoring capabilities', 'Here’s the deal: LangChain is like building the entire car, while LangSmith is your diagnostic tool to ensure that car runs smoothly. When it comes to practical application, I always say: “Show, don’t tell.” I’ve used both LangChain and LangSmith extensively, and I’ve found that they complement each other beautifully when you’re building and fine-tuning LLM-based workflows. Having spent countless hours building and debugging LLM-based systems, I’ve learned that using LangChain and LangSmith effectively requires a few smart strategies. I often use LangChain to build my pipelines and LangSmith to monitor and debug them. Start with LangChain to build your pipeline, and then bring in LangSmith to ensure it performs as expected.', 'LangSmith is a monitoring and testing tool for LLM applications in production. It helps developers ensure their systems are efficient, reliable, and cost-effective. Key Features:', 'LangChain and LangSmith are two complementary tools that cater to different stages and requirements of LLM development. LangChain is ideal for early-stage prototyping and small-scale applications, while LangSmith is better suited for large-scale, production-ready applications that require advanced debugging, testing, and monitoring capabilities.', 'Their solution orchestrates multiple AI agents working in parallel to gather, structure, and process data with human-level accuracy. This case study demonstrates a sophisticated implementation of LLMOps practices using LangChain and LangSmith for building and operating production-grade AI systems.', \"LangChain x Five Sigma x Google Cloud case study | ABN Software Five Sigma recently introduced Clive™ - the insurance industrys first AI Claims Adjuster. In this tech article from ABN, you will learn how Five Sigma, an insurance company, has strealined insurance claims with LangChain, Google's Vertex AI and implementation partner. Five Sigma is streamlining insurance claims with Clive, their AI agent built on LangChain and powered by Google Cloud's Vertex AI. By integrating LangChain’s cutting-edge NLP capabilities with Google Cloud’s scale and AI models, Five Sigma has developed an AI product that transforms how insurance companies manage claims. After rigorous testing with LangSmith, the Five Sigma team has confidently deployed Clive into production and helped insurers handle claims smarter and faster.\", 'As we move into 2025, the rapid advancements in Artificial Intelligence (AI) and its growing integration into everyday life promise transformative changes across industries, particularly in language processing and translation. In this comprehensive overview, we outline the pivotal changes expected in 2025, with a focus on how AI technologies are redefining language processing and translation, along with broader AI trends that will influence industries worldwide. This section explores the advancements and future trends in AI-driven language processing, with a focus on localization and translation technologies in 2025. In 2025, AI-driven “No Human in the Loop” (NHITL) translation systems are revolutionizing language processing, reshaping workflows across industries.', 'Discover the top trends in natural language processing (NLP) for 2025, including AI-driven content generation, multimodal learning, sentiment analysis, and more. Stay informed about the future of NLP and its impact on various sectors.', \"This paper presents a vivid comparative analysis of the top 9 generative artificial intelligence (AI) tools, namely ChatGPT, Perplexity AI, YouChat, ChatSonic, Google's Bard, Microsoft Bing\", 'Artificial Intelligence (AI) has become a valuable tool in the field of natural language processing, particularly in the field of literary translation. To address this issue, an extensive assessment was conducted to analyze and compare the effectiveness of Copilot 4 and ChatGPT 4 specifically in literary translation.']}}\n",
      "{'generate': {'draft': \"### The Difference Between LangChain and LangSmith\\n\\n#### I. Introduction\\nIn the rapidly evolving landscape of artificial intelligence (AI) and language processing, tools like LangChain and LangSmith have emerged as pivotal players. LangChain is primarily designed for building and managing language model workflows, while LangSmith serves as a diagnostic and monitoring tool to ensure these workflows operate smoothly. Understanding the differences between these two tools is crucial for developers and organizations looking to leverage AI effectively. This essay aims to compare and contrast LangChain and LangSmith, providing insights into their respective use cases and functionalities.\\n\\n#### II. Overview of LangChain\\nLangChain is a robust framework that facilitates the development of applications powered by large language models (LLMs). Its primary functions include building pipelines that integrate various AI models and managing workflows efficiently. Key features of LangChain include its ability to orchestrate multiple AI agents, enabling them to work in parallel to gather, structure, and process data with human-level accuracy. LangChain is particularly beneficial in industries such as finance, healthcare, and customer service, where it can streamline operations and enhance decision-making processes. For instance, companies can use LangChain to develop chatbots that provide real-time customer support or to automate data analysis tasks.\\n\\n#### III. Overview of LangSmith\\nIn contrast, LangSmith is a specialized tool focused on monitoring and testing LLM applications in production environments. Its primary functions revolve around ensuring that AI systems are efficient, reliable, and cost-effective. LangSmith offers advanced debugging and orchestration features, making it indispensable for developers managing complex AI pipelines. Use cases for LangSmith include monitoring the performance of AI models in real-time, conducting thorough testing to identify potential issues, and providing insights into system efficiency. Industries such as insurance and e-commerce benefit significantly from LangSmith, as it allows them to deploy AI solutions confidently, knowing they are backed by robust monitoring capabilities. A notable example is Five Sigma's Clive™, an AI claims adjuster that was rigorously tested with LangSmith before deployment.\\n\\n#### IV. Comparative Analysis\\nThe key differences between LangChain and LangSmith lie in their functionalities and target audiences. LangChain excels in building and scaling model workflows, making it ideal for early-stage prototyping and small-scale applications. In contrast, LangSmith is tailored for large-scale, production-ready applications that require deep visibility and control over AI systems. While LangChain focuses on the development phase, LangSmith is essential for the operational phase, ensuring that the systems built with LangChain perform as expected. Despite these differences, both tools share common goals in language processing, such as enhancing the efficiency and effectiveness of AI applications.\\n\\n#### V. Advantages and Disadvantages\\nLangChain offers several advantages, including its user-friendly interface and strong community support, which fosters collaboration and innovation. Its strengths lie in specific applications like chatbot development and data analysis automation. However, it may face limitations in monitoring capabilities, which is where LangSmith shines. On the other hand, LangSmith's advantages include its advanced debugging features and real-time monitoring, making it a go-to tool for developers managing complex AI systems. Nevertheless, it may not be as effective for early-stage prototyping, where LangChain's capabilities are more beneficial. Both tools have their unique strengths and challenges, and the choice between them often depends on the specific needs of the user.\\n\\n#### VI. Conclusion\\nIn summary, LangChain and LangSmith serve distinct yet complementary roles in the realm of AI and language processing. LangChain is ideal for building and managing workflows, while LangSmith provides the necessary monitoring and debugging capabilities to ensure those workflows operate smoothly in production. When choosing between the two, organizations should consider their specific needs, whether they are in the development phase or require robust monitoring for deployed applications. As AI technologies continue to advance, the integration of tools like LangChain and LangSmith will play a crucial role in shaping the future of language processing and AI-driven solutions.\", 'revision_number': 3}}\n"
     ]
    }
   ],
   "source": [
    "thread = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "for s in graph.stream({\n",
    "    'task': \"what is the difference between langchain and langsmith\",\n",
    "    \"max_revisions\": 2,\n",
    "    \"revision_number\": 1,\n",
    "}, thread):\n",
    "    print(s)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}