Building a Simple LLM Content Creation Application with LangChain

What We Will Learn

After completing this tutorial, you'll have a comprehensive understanding of:

• Utilizing language models.
• Employing PromptTemplates and OutputParsers.
• Chaining components together using LangChain Expression Language (LCEL).
• Debugging and tracing your application using LangSmith.
• Deploying your application via LangServe.

So, let's dive right into creating an innovative content creation application!

Setup

Jupyter Notebook

For this tutorial, we recommend using a Jupyter Notebook due to its interactive nature, which is invaluable for troubleshooting issues such as unexpected output or API downtime. If you haven't already, follow these instructions to install Jupyter Notebook.

Installation

To install LangChain, open your terminal and run:

pip install langchain

Refer to the Installation guide for more detailed instructions.

LangSmith for Observability

As your LLM applications become more complex, understanding what's happening inside each chain or agent becomes crucial. LangSmith offers this functionality. Once you sign up, set your environment variables as follows:

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

If you’re using a notebook:

import getpass

import os

os.environ["LANGCHAIN_TRACING_V2"] = "true"

os.environ["LANGCHAIN_API_KEY"] = getpass.getpass()

Using Language Models

Let's start by using a language model. LangChain supports many models, such as OpenAI, Anthropic, Azure, Google, Cohere, FireworksAI, MistralAI, and TogetherAI. For this guide, we will use OpenAI’s GPT-4.

pip install -qU langchain-openai

import getpass

import os

os.environ["OPENAI_API_KEY"] = getpass.getpass()

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4")

Next, we'll invoke this model to generate content based on a user prompt.

from langchain_core.messages import HumanMessage, SystemMessage



messages = [

    SystemMessage(content="Please generate a blog post about the benefits of learning a second language."),

    HumanMessage(content=""),

]

response = model.invoke(messages)

print(response.content)

OutputParsers

The response from the model is an AIMessage, comprising both the string response and metadata. Often, you only need the string. You can use an OutputParser for this task:

from langchain_core.output_parsers import StrOutputParser



parser = StrOutputParser()

parsed_response = parser.invoke(response)

print(parsed_response)

For a more streamlined approach, you can chain the model and parser:

chain = model | parser

print(chain.invoke(messages))

PromptTemplates

To dynamically create prompts, we use PromptTemplates:

from langchain_core.prompts import ChatPromptTemplate



system_template = "Please generate a blog post about {topic}:"

prompt_template = ChatPromptTemplate.from_messages([("system", system_template), ("user", "")])

You can test this template as shown below:

result = prompt_template.invoke({"topic": "the benefits of learning a second language"})

print(result.to_messages())

Chaining Components with LCEL

Chain the prompt template, model, and output parser together:

chain = prompt_template | model | parser

print(chain.invoke({"topic": "the benefits of learning a second language"}))

Serving with LangServe

To deploy our application, we use LangServe. Create a Python file (serve.py) with the following content:

from fastapi import FastAPI

from langchain_core.prompts import ChatPromptTemplate

from langchain_core.output_parsers import StrOutputParser

from langchain_openai import ChatOpenAI

from langserve import add_routes



system_template = "Please generate a blog post about {topic}:"

prompt_template = ChatPromptTemplate.from_messages([("system", system_template), ("user", "")])

model = ChatOpenAI()

parser = StrOutputParser()

chain = prompt_template | model | parser



app = FastAPI(title="LangChain Server", version="1.0", description="A simple API server using LangChain's Runnable interfaces")

add_routes(app, chain, path="/chain")



if __name__ == "__main__":

    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

Run this script:

python serve.py

Use Cases

While this guide focuses on content creation for blogs, LangChain has myriad other applications:

1. Social Media Management: Automatically generate social media posts tailored to different platforms.
2. Email Marketing: Create personalized email campaigns with tailored content for different audience segments.
3. SEO Optimization: Generate content optimized for search engines, including keywords and meta descriptions.
4. Product Descriptions: Quickly write detailed and engaging product descriptions for e-commerce platforms.
5. Creative Writing: Assist writers by generating story ideas, character descriptions, and even entire short stories or chapters.

Conclusion

Congratulations! You’ve built a simple yet powerful LLM application for content creation. You’ve learned how to chain components with LCEL, debug, and trace with LangSmith, and finally, deploy your app using LangServe. This guide only scratches the surface of what LangChain can do, so stay tuned for more advanced tutorials!

Happy Coding!