# You'll be working with simple strings (that'll soon grow in complexity!)
my_text = "What day comes after Friday?"

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage, AIMessage

chat = ChatOpenAI(temperature=0.7, openai_api_key="YourAPIKey")
chat([SystemMessage(content="You are a nice AI bot that helps a user figure out what to eat in one short sentence"), HumanMessage(content="I like tomatoes, what should I eat?")])

AIMessage(content='You could try making a tomato salad with fresh basil and mozzarella cheese.', additional_kwargs={})

from langchain.schema import Document

Document(
    page_content="This is my document. It is full of text that I've gathered from other places",
    metadata={"my_document_id": 234234, "my_document_source": "The LangChain Papers", "my_document_create_time": 1680013019},
)

Document(page_content="This is my document. It is full of text that I've gathered from other places", lookup_str='', metadata={'my_document_id': 234234, 'my_document_source': 'The LangChain Papers', 'my_document_create_time': 1680013019}, lookup_index=0)

from langchain.llms import OpenAI

llm = OpenAI(model_name="text-ada-001", openai_api_key="YourAPIKey")

llm("What day comes after Friday?")

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage, AIMessage

chat = ChatOpenAI(temperature=1, openai_api_key="YourAPIKey")

chat([SystemMessage(content="You are an unhelpful AI bot that makes a joke at whatever the user says"), HumanMessage(content="I would like to go to New York, how should I do this?")])

AIMessage(content="You could try walking, but I don't recommend it unless you have a lot of time on your hands. Maybe try flapping your arms really hard and see if you can fly there?", additional_kwargs={})

from langchain.embeddings import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(openai_api_key="YourAPIKey")

text = "Hi! It's time for the beach"

text_embedding = embeddings.embed_query(text)
print(f"Your embedding is length {len(text_embedding)}")
print(f"Here's a sample: {text_embedding[:5]}...")

from langchain.llms import OpenAI

llm = OpenAI(model_name="text-davinci-003", openai_api_key="YourAPIKey")  # I like to use three double quotation marks for my prompts because it's easier to read

prompt = """ Today is Monday, tomorrow is Wednesday. What is wrong with that statement? """

llm(prompt)

from langchain.llms import OpenAI
from langchain import PromptTemplate

llm = OpenAI(model_name="text-davinci-003", openai_api_key="YourAPIKey")  # Notice "location" below, that is a placeholder for another value later

template = """ I really want to travel to {location}. What should I do there? Respond in one short sentence """

prompt = PromptTemplate(
    input_variables=["location"],
    template=template,
)

final_prompt = prompt.format(location="Rome")

print(f"Final Prompt: {final_prompt}")

print("-----------")

print(f"LLM Output: {llm(final_prompt)}")

Final Prompt:
I really want to travel to Rome. What should I do there?

Respond in one short sentence

-----------
LLM Output:
Visit the Colosseum, the Pantheon, and the Trevi Fountain for a taste of Rome's ancient and modern culture.

from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import FewShotPromptTemplate, PromptTemplate
from langchain.llms import OpenAI

llm = OpenAI(model_name="text-davinci-003", openai_api_key="YourAPIKey")

example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Example Input: {input}\nExample Output: {output}",
)

# Examples of locations that nouns are found

examples = [
    {"input": "pirate", "output": "ship"},
    {"input": "pilot", "output": "plane"},
    {"input": "driver", "output": "car"},
    {"input": "tree", "output": "ground"},
    {"input": "bird", "output": "nest"},
]

# SemanticSimilarityExampleSelector will select examples that are similar to your input by semantic meaning

example_selector = SemanticSimilarityExampleSelector.from_examples(
    # This is the list of examples available to select from.
    examples,
    # This is the embedding class used to produce embeddings which are used to measure semantic similarity.
    OpenAIEmbeddings(openai_api_key=openai_api_key),
    # This is the VectorStore class that is used to store the embeddings and do a similarity search over.
    FAISS,
    # This is the number of examples to produce.
    k=2,
)

similar_prompt = FewShotPromptTemplate(
    # The object that will help select examples
    example_selector=example_selector,
    # Your prompt
    example_prompt=example_prompt,
    # Customizations that will be added to the top and bottom of your prompt
    prefix="Give the location an item is usually found in",
    suffix="Input: {noun}\nOutput:",
    # What inputs your prompt will receive
    input_variables=["noun"],
)

# Select a noun!
my_noun = "student"

print(similar_prompt.format(noun=my_noun))

Give the location an item is usually found in

Example Input: driver
Example Output: car

Example Input: pilot
Example Output: plane

Input: student
Output:

from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain.llms import OpenAI

llm = OpenAI(model_name="text-davinci-003", openai_api_key="YourAPIKey")

# How you would like your reponse structured. This is basically a fancy prompt template

response_schemas = [
    ResponseSchema(name="bad_string", description="This a poorly formatted user input string"),
    ResponseSchema(name="good_string", description="This is your response, a reformatted response"),
]

# How you would like to parse your output
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)

# See the prompt template you created for formatting
format_instructions = output_parser.get_format_instructions()
print(format_instructions)

json
{
	"bad_string": string  // This a poorly formatted user input string
	"good_string": string  // This is your response, a reformatted response
}

template = (
    """ You will be given a poorly formatted string from a user. Reformat it and make sure all the words are spelled correctly {format_instructions} % USER INPUT: {user_input} YOUR RESPONSE: """
)

prompt = PromptTemplate(input_variables=["user_input"], partial_variables={"format_instructions": format_instructions}, template=template)

promptValue = prompt.format(user_input="welcom to califonya!")

print(promptValue)

json\n{\n\t"bad_string": "welcom to califonya!",\n\t"good_string": "Welcome to California!"\n}\n

from langchain.document_loaders import HNLoader

loader = HNLoader("https://news.ycombinator.com/item?id=34422627")

data = loader.load()

print(f"Found {len(data)} comments")
print(f"Here's a sample:\n\n{''.join([x.page_content[:150] for x in data[:2]])}")

Found 76 comments
Here's a sample:

dang 69 days ago
             | next [–]

Related ongoing thread:GPT-3.5 and Wolfram Alpha via LangChain - https://news.ycombinator.com/item?id=344Ozzie_osman 69 days ago
             | prev | next [–]

LangChain is awesome. For people not sure what it's doing, large language models (LLMs) are

from langchain.text_splitter import RecursiveCharacterTextSplitter

# This is a long document we can split up.
with open("data/PaulGrahamEssays/worked.txt") as f:
    pg_work = f.read()

print(f"You have {len([pg_work])} document")

text_splitter = RecursiveCharacterTextSplitter(
    # Set a really small chunk size, just to show.
    chunk_size=150,
    chunk_overlap=20,
)

texts = text_splitter.create_documents([pg_work])

print(f"You have {len(texts)} documents")

print("Preview:")
print(texts[0].page_content, "\n")
print(texts[1].page_content)

Preview:
February 2021Before college the two main things I worked on, outside of school,
were writing and programming. I didn't write essays. I wrote what

beginning writers were supposed to write then, and probably still
are: short stories. My stories were awful. They had hardly any plot,

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

loader = TextLoader("data/PaulGrahamEssays/worked.txt")
documents = loader.load()

# Get your splitter ready
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=50)

# Split your docs into texts
texts = text_splitter.split_documents(documents)

# Get embedding engine ready
embeddings = OpenAIEmbeddings(openai_api_key="YourAPIKey")

# Embedd your texts
db = FAISS.from_documents(texts, embeddings)

# Init your retriever. Asking for just 1 document back
retriever = db.as_retriever()

VectorStoreRetriever(vectorstore=<langchain.vectorstores.faiss.FAISS object at 0x7fb81007a9d0>, search_type='similarity', search_kwargs={})

docs = retriever.get_relevant_documents("what types of things did the author want to build?")

print("\n\n".join([x.page_content[:200] for x in docs[:2]]))

standards; what was the point? No one else wanted one either, so
off they went. That was what happened to systems work.I wanted not just to build things, but to build things that would
last.In this di

much of it in grad school.Computer Science is an uneasy alliance between two halves, theory
and systems. The theory people prove things, and the systems people
build things. I wanted to build things.

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

loader = TextLoader("data/PaulGrahamEssays/worked.txt")
documents = loader.load()

# Get your splitter ready
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=50)

# Split your docs into texts
texts = text_splitter.split_documents(documents)

# Get embedding engine ready
embeddings = OpenAIEmbeddings(openai_api_key="YourAPIKey")

print(f"You have {len(texts)} documents")

You have 78 documents

embedding_list = embeddings.embed_documents([text.page_content for text in texts])

print(f"You have {len(embedding_list)} embeddings")
print(f"Here's a sample of one: {embedding_list[0][:3]}...")

You have 78 embeddings
Here's a sample of one: [-0.0011257503647357225, -0.01111479103565216, -0.012860921211540699]...

from langchain.memory import ChatMessageHistory
from langchain.chat_models import ChatOpenAI

chat = ChatOpenAI(temperature=0, openai_api_key="YourAPIKey")

history = ChatMessageHistory()

history.add_ai_message("hi!")

history.add_user_message("what is the capital of france?")

ai_response = chat(history.messages)

AIMessage(content='The capital of France is Paris.', additional_kwargs={})

history.add_ai_message(ai_response.content)

from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.chains import SimpleSequentialChain

llm = OpenAI(temperature=1, openai_api_key="YourAPIKey")

template = """Your job is to come up with a classic dish from the area that the users suggests. % USER LOCATION {user_location} YOUR RESPONSE: """
prompt_template = PromptTemplate(input_variables=["user_location"], template=template)

# Holds my 'location' chain
location_chain = LLMChain(llm=llm, prompt=prompt_template)

template = """Given a meal, give a short and simple recipe on how to make that dish at home. % MEAL {user_meal} YOUR RESPONSE: """
prompt_template = PromptTemplate(input_variables=["user_meal"], template=template)

# Holds my 'meal' chain
meal_chain = LLMChain(llm=llm, prompt=prompt_template)

overall_chain = SimpleSequentialChain(chains=[location_chain, meal_chain], verbose=True)

review = overall_chain.run("Rome")

> Entering new SimpleSequentialChain chain...
A classic dish from Rome is Spaghetti alla Carbonara, a pasta dish made with egg, cheese, guanciale (cured pork cheek), and black pepper.

Ingredients:
-1/2 lb. spaghetti
-4 oz. guanciale, diced
-2 cloves garlic, minced
-2 eggs
-2/3 cup Parmigiano Reggiano cheese, divided
-1/4 tsp. freshly cracked black pepper
-1/4 cup reserved pasta water
-2 tablespoons olive oil
-Parsley for garnish (optional)

Instructions:
1. Boil spaghetti in a large pot of salted boiling water until al dente, about 8 minutes. Reserve 1/4 cup of cooking water and drain the spaghetti.

2. In a large skillet, heat oil over medium-high heat, then add guanciale and sauté until lightly brown, about 5 minutes.

3. Add garlic and sauté for an additional 1-2 minutes.

4. In a medium bowl, whisk together eggs and 1/3 cup Parmigiano Reggiano cheese.

5. Add cooked spaghetti to the large skillet, toss to combine, then reduce the heat to medium-low.

6. Pour in the egg and cheese mixture, then add pepper and reserved pasta water.

7. Toss pasta

> Finished chain.

from langchain.chains.summarize import load_summarize_chain
from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = TextLoader("data/PaulGrahamEssays/disc.txt")

documents = loader.load()

# Get your splitter ready
text_splitter = RecursiveCharacterTextSplitter(chunk_size=700, chunk_overlap=50)

# Split your docs into texts
texts = text_splitter.split_documents(documents)

# There is a lot of complexity hidden in this one line. I encourage you to check out the video above for more detail
chain = load_summarize_chain(llm, chain_type="map_reduce", verbose=True)
chain.run(texts)

> Entering new MapReduceDocumentsChain chain...
Prompt after formatting:
Write a concise summary of the following:


"January 2017Because biographies of famous scientists tend to
edit out their mistakes, we underestimate the
degree of risk they were willing to take.
And because anything a famous scientist did that
wasn't a mistake has probably now become the
conventional wisdom, those choices don't
seem risky either.Biographies of Newton, for example, understandably focus
more on physics than alchemy or theology.
The impression we get is that his unerring judgment
led him straight to truths no one else had noticed.
How to explain all the time he spent on alchemy
and theology?  Well, smart people are often kind of
crazy.But maybe there is a simpler explanation. Maybe"


CONCISE SUMMARY:
Prompt after formatting:
Write a concise summary of the following:


"the smartness and the craziness were not as separate
as we think. Physics seems to us a promising thing
to work on, and alchemy and theology obvious wastes
of time. But that's because we know how things
turned out. In Newton's day the three problems
seemed roughly equally promising. No one knew yet
what the payoff would be for inventing what we
now call physics; if they had, more people would
have been working on it. And alchemy and theology
were still then in the category Marc Andreessen would
describe as "huge, if true."Newton made three bets. One of them worked. But
they were all risky."


CONCISE SUMMARY:


> Entering new LLMChain chain...
Prompt after formatting:
Write a concise summary of the following:


" Biographies of famous scientists often omit the risks they took and the mistakes they made during their lifetime. This gives us an impression that these scientists had a perfect judgement, when in fact they made unwise decisions like Newton's dabblings in alchemy and theology. Perhaps these scientists were just taking risks and making mistakes like anyone else.


This passage discusses how, in the time of Sir Isaac Newton, the three areas of study – physics, alchemy, and theology – were all considered equally valuable and worthy of exploration. Newton's success in the area of physics has since made the others seem like a waste of time, however at the point of Newton's exploration, all three were seen as high-risk but high-reward propositions."


CONCISE SUMMARY:

> Finished chain.

> Finished chain.
" Biographies of famous scientists often omit the risks they took and mistakes they made, creating an impression of perfect judgement. Sir Isaac Newton's exploration of physics, alchemy, and theology was seen as all high-risk but high-reward propositions at the time, and should not be overlooked."

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.llms import OpenAI
import json

llm = OpenAI(temperature=0, openai_api_key="YourAPIKey")

serpapi_api_key = "..."

toolkit = load_tools(["serpapi"], llm=llm, serpapi_api_key=serpapi_api_key)

agent = initialize_agent(toolkit, llm, agent="zero-shot-react-description", verbose=True, return_intermediate_steps=True)

response = agent({"input": "what was the first album of the" "band that Natalie Bergman is a part of?"})

> Entering new AgentExecutor chain...
 I should try to find out what band Natalie Bergman is a part of.
Action: Search
Action Input: "Natalie Bergman band"
Observation: Natalie Bergman is an American singer-songwriter. She is one half of the duo Wild Belle, along with her brother Elliot Bergman. Her debut solo album, Mercy, was released on Third Man Records on May 7, 2021. She is based in Los Angeles.
Thought: I should search for the debut album of Wild Belle.
Action: Search
Action Input: "Wild Belle debut album"
Observation: Isles
Thought: I now know the final answer.
Final Answer: Isles is the debut album of Wild Belle, the band that Natalie Bergman is a part of.

> Finished chain.