Harrison/docs (#23)

* stash

* cr

* cr

Author: hwchase17

docs/docs/getting-started.md

@@ -178,23 +178,16 @@ Now we can get started!
 
 ```typescript
 import { OpenAI } from "langchain";
-import { loadAgent, AgentExecutor } from "langchain/agents";
+import { initializeAgentExecutor } from "langchain/agents";
 import { SerpAPI, Calculator } from "langchain/tools";
 
-const model = new OpenAI();
+const model = new OpenAI({temperature: 0});
 const tools = [new SerpAPI(), new Calculator()];
 
-const agent = await loadAgent(
-"lc://agents/zero-shot-react-description/agent.json",
-{ llm: model, tools }
+const executor = await initializeAgentExecutor(
+    tools, model, "zero-shot-react-description"
 );
-console.log("Loaded agent from Langchain hub");
-
-const executor = AgentExecutor.fromAgentAndTools({
-agent,
-tools,
-returnIntermediateSteps: true,
-});
+console.log("Loaded agent.");
 
 const input = "Who is Olivia Wilde's boyfriend?" +
 " What is his current age raised to the 0.23 power?";

docs/docs/modules/agents/getting_started.md

@@ -0,0 +1,51 @@
+# Load from Hub
+
+[LangChainHub](https://github.com/hwchase17/langchain-hub) contains a collection of chains which can be loaded directly via LangChain.
+
+For this example, you will also need to install the SerpAPI Python package.
+
+```bash
+npm i serpapi
+```
+
+And set the appropriate environment variables in the `.env` file.
+
+```
+SERPAPI_API_KEY="..."
+```
+
+Now we can get started!
+
+```typescript
+import { OpenAI } from "langchain";
+import { loadAgent, AgentExecutor } from "langchain/agents";
+import { SerpAPI, Calculator } from "langchain/tools";
+
+const model = new OpenAI();
+const tools = [new SerpAPI(), new Calculator()];
+
+const agent = await loadAgent(
+"lc://agents/zero-shot-react-description/agent.json",
+{ llm: model, tools }
+);
+console.log("Loaded agent from Langchain hub");
+
+const executor = AgentExecutor.fromAgentAndTools({
+agent,
+tools,
+returnIntermediateSteps: true,
+});
+
+const input = "Who is Olivia Wilde's boyfriend?" +
+" What is his current age raised to the 0.23 power?";
+console.log(`Executing with input "${input}"...`);
+
+const result = await executor.call({ input });
+
+console.log(`Got output ${result.output}`);
+```
+
+```shell
+langchain-examples:start: Executing with input "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?"...
+langchain-examples:start: Got output Olivia Wilde's boyfriend is Jason Sudeikis, and his current age raised to the 0.23 power is 2.4242784855673896.
+```

docs/docs/modules/agents/load_from_hub.md

@@ -0,0 +1,53 @@
+# Agent Overview
+
+Agents use an LLM to determine which actions to take and in what order. An action can either be using a tool and observing its output, or returning to the user.
+
+When used correctly agents can be extremely powerful. In this tutorial, we show you how to easily use agents through the simplest, highest level API.
+
+
+In order to load agents, you should understand the following concepts:
+
+- Tool: A function that performs a specific duty. This can be things like: Google Search, Database lookup, code REPL, other chains. The interface for a tool is currently a function that is expected to have a string as an input, with a string as an output.
+- LLM: The language model powering the agent.
+- Agent: The agent to use. This should be a string that references a support agent class. Because this notebook focuses on the simplest, highest level API, this only covers using the standard supported agents.
+
+For this example, you will also need to install the SerpAPI Python package.
+
+```bash
+npm i serpapi
+```
+
+And set the appropriate environment variables in the `.env` file.
+
+```
+SERPAPI_API_KEY="..."
+```
+
+Now we can get started!
+
+```typescript
+import { OpenAI } from "langchain";
+import { initializeAgentExecutor } from "langchain/agents";
+import { SerpAPI, Calculator } from "langchain/tools";
+
+const model = new OpenAI({temperature: 0});
+const tools = [new SerpAPI(), new Calculator()];
+
+const executor = await initializeAgentExecutor(
+    tools, model, "zero-shot-react-description"
+);
+console.log("Loaded agent.");
+
+const input = "Who is Olivia Wilde's boyfriend?" +
+" What is his current age raised to the 0.23 power?";
+console.log(`Executing with input "${input}"...`);
+
+const result = await executor.call({ input });
+
+console.log(`Got output ${result.output}`);
+```
+
+```shell
+langchain-examples:start: Executing with input "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?"...
+langchain-examples:start: Got output Olivia Wilde's boyfriend is Jason Sudeikis, and his current age raised to the 0.23 power is 2.4242784855673896.
+```

docs/docs/modules/agents/overview.md

@@ -0,0 +1,11 @@
+# Load from Hub
+
+[LangChainHub](https://github.com/hwchase17/langchain-hub) contains a collection of chains which can be loaded directly via LangChain.
+
+```typescript
+import { loadChain } from "langchain/chains";
+
+const chain = await loadChain("lc://chains/hello-world/chain.json");
+const res = chain.call({topic: "foo"});
+console.log(res);
+```

docs/docs/modules/chains/load_from_hub.md

@@ -0,0 +1,16 @@
+# Vectorstores
+
+A vectorstore is a particular type of database optimized for storing documents, embeddings, and then allowing for fetching of the most relevant documents for a particular query.
+
+```typescript
+import { HNSWLib } from "langchain/vectorstores";
+import { OpenAIEmbeddings } from "langchain/embeddings";
+
+const vectorStore = await HNSWLib.fromTexts(
+["Hello world", "Bye bye", "hello nice world"],
+[{ id: 2 }, { id: 1 }, { id: 3 }],
+new OpenAIEmbeddings()
+);
+
+const resultOne = await vectorStore.similaritySearch("hello world", 1);
+```

docs/docs/modules/indexes/vectorstore.md

@@ -1,4 +1,4 @@
-### Buffer Memory
+# Buffer Memory
 
 BufferMemory is the simplest type of memory - it just remembers previous conversational back and forths directly.
 

docs/docs/modules/memory/buffer_memory.md

@@ -7,4 +7,4 @@ import { loadPrompt } from "langchain/prompt";
 const prompt = await loadPrompt("lc://prompts/hello-world/prompt.yaml");
 const res = prompt.format({});
 console.log({ res });
-```
+```

docs/docs/modules/prompts/load_from_hub.md

@@ -1,4 +1,4 @@
-### Prompt Templates
+# Prompt Templates
 
 This example walks through how to use PromptTemplates.
 At their core, prompt templates are objects that are made up of a template with certain input variables.
@@ -19,4 +19,4 @@ console.log({ res });
 
 ```shell
 { res: 'What is a good name for a company that makes colorful socks?' }
-```
+```

docs/docs/modules/prompts/prompt_template.md

@@ -0,0 +1,56 @@
+# Welcome to LangChain
+
+Large language models (LLMs) are emerging as a transformative technology, enabling
+developers to build applications that they previously could not.
+But using these LLMs in isolation is often not enough to
+create a truly powerful app - the real power comes when you are able to
+combine them with other sources of computation or knowledge.
+
+This library is aimed at assisting in the development of those types of applications. Common examples of these types of applications include:
+
+- ❓[Question Answering over specific documents](./modules/chains/question_answering.md)
+- 💬 [Chatbots](./modules/memory/buffer_memory.md)
+- 🤖 [Agents](./modules/agents/overview.md)
+
+## Getting Started
+
+Checkout the below guide for a walkthrough of how to get started using LangChain to create an Language Model application.
+
+- [Getting Started Documentation](./getting-started.md)
+
+## Modules
+
+There are several main modules that LangChain provides support for.
+For each module we provide some examples to get started and get familiar with some of the concepts.
+These modules are, in increasing order of complexity:
+
+
+- Prompts: This includes prompt management, prompt optimization, and prompt serialization.
+
+- LLMs: This includes a generic interface for all LLMs, and common utilities for working with LLMs.
+
+- Indexes: This includes patterns and functionality for structuring your own text data so it can interact with language models (including embeddings, vectorstores, text splitters, etc).
+
+- Chains: Chains go beyond just a single LLM call, and are sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.
+
+- Agents: Agents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end to end agents.
+
+- Memory: Memory is the concept of persisting state between calls of a chain/agent. LangChain provides a standard interface for memory, a collection of memory implementations, and examples of chains/agents that use memory.
+
+
+## Reference Docs
+---------------
+
+All of LangChain's reference documentation, in one place. Full documentation on all methods and classes. 
+
+
+## Additional Resources
+---------------------
+
+Additional collection of resources we think may be useful as you develop your application!
+
+- [LangChainHub](https://github.com/hwchase17/langchain-hub): The LangChainHub is a place to share and explore other prompts, chains, and agents.
+
+- [Discord](https://discord.gg/6adMQxSpJS): Join us on our Discord to discuss all things LangChain!
+
+- [Production Support](https://forms.gle/57d8AmXBYp8PP8tZA): As you move your LangChains into production, we'd love to offer more comprehensive support. Please fill out this form and we'll set up a dedicated support Slack channel.