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

or

uvicorn serve:app --reload

Test the server Head to http://localhost:8000/chain/playground to try it out!

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!