From 36c9fd1af731ba19bbc381d7578a915b8a48e83d Mon Sep 17 00:00:00 2001
From: Davis Chase <130488702+dev2049@users.noreply.github.com>
Date: Mon, 15 May 2023 15:20:37 -0700
Subject: [PATCH] Dev2049/docs edit0 (#4699)
---
docs/index.rst | 71 +++++++++++++++++++++++++-------------------------
1 file changed, 36 insertions(+), 35 deletions(-)
diff --git a/docs/index.rst b/docs/index.rst
index 7c4cf93c..0a0ff58b 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -1,27 +1,26 @@
Welcome to LangChain
==========================
-LangChain is a framework for developing applications powered by language models. We believe that the most powerful and differentiated applications will not only call out to a language model via an API, but will also:
+| **LangChain** is a framework for developing applications powered by language models. We believe that the most powerful and differentiated applications will not only call out to a language model, but will also be:
+1. *Data-aware*: connect a language model to other sources of data
+2. *Agentic*: allow a language model to interact with its environment
-- *Be data-aware*: connect a language model to other sources of data
-- *Be agentic*: allow a language model to interact with its environment
+| The LangChain framework is designed around these principles.
-The LangChain framework is designed with the above principles in mind.
-
-This is the Python specific portion of the documentation. For a purely conceptual guide to LangChain, see `here `_. For the JavaScript documentation, see `here `_.
+| This is the Python specific portion of the documentation. For a purely conceptual guide to LangChain, see `here `_. For the JavaScript documentation, see `here `_.
Getting Started
----------------
-How to get started using LangChain to create an Language Model application.
+| How to get started using LangChain to create an Language Model application.
-- `Getting Started tutorial <./getting_started/getting_started.html>`_
+- `Quickstart Guide <./getting_started/getting_started.html>`_
-Concepts and terminology.
+| Concepts and terminology.
- `Concepts and terminology <./getting_started/concepts.html>`_
-Tutorials created by community experts and presented on YouTube.
+| Tutorials created by community experts and presented on YouTube.
- `Tutorials <./getting_started/tutorials.html>`_
@@ -39,24 +38,26 @@ Tutorials created by community experts and presented on YouTube.
Modules
-----------
-There are several main modules that LangChain provides support for.
-For each module we provide some examples to get started, how-to guides, reference docs, and conceptual guides.
-These modules are, in increasing order of complexity:
+| These modules are the core abstractions which we view as the building blocks of any LLM-powered application.
+For each module LangChain provides standard, extendable interfaces. LanghChain also provides external integrations and even end-to-end implementations for off-the-shelf use.
+
+| The docs for each module contain quickstart examples, how-to guides, reference docs, and conceptual guides.
-- `Models <./modules/models.html>`_: The various model types and model integrations LangChain supports.
+| The modules are (from least to most complex):
-- `Prompts <./modules/prompts.html>`_: This includes prompt management, prompt optimization, and prompt serialization.
+- `Models <./modules/models.html>`_: Supported model types and integrations.
-- `Memory <./modules/memory.html>`_: 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.
+- `Prompts <./modules/prompts.html>`_: Prompt management, optimization, and serialization.
-- `Indexes <./modules/indexes.html>`_: Language models are often more powerful when combined with your own text data - this module covers best practices for doing exactly that.
+- `Memory <./modules/memory.html>`_: Memory refers to state that is persisted between calls of a chain/agent.
-- `Chains <./modules/chains.html>`_: 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.
+- `Indexes <./modules/indexes.html>`_: Language models become much more powerful when combined with application-specific data - this module contains interfaces and integrations for loading, querying and updating external data.
-- `Agents <./modules/agents.html>`_: 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.
+- `Chains <./modules/chains.html>`_: Chains are structured sequences of calls (to an LLM or to a different utility).
-- `Callbacks <./modules/callbacks/getting_started.html>`_: It can be difficult to track all that occurs inside a chain or agent - callbacks help add a level of observability and introspection.
+- `Agents <./modules/agents.html>`_: An agent is a Chain in which an LLM, given a high-level directive and a set of tools, repeatedly decides an action, executes the action and observes the outcome until the high-level directive is complete.
+- `Callbacks <./modules/callbacks/getting_started.html>`_: Callbacks let you log and stream the intermediate steps of any chain, making it easy to observe, debug, and evaluate the internals of an application.
.. toctree::
:maxdepth: 1
@@ -75,29 +76,29 @@ These modules are, in increasing order of complexity:
Use Cases
----------
-The above modules can be used in a variety of ways. LangChain also provides guidance and assistance in this. Below are some of the common use cases LangChain supports.
+| Best practices and built-in implementations for common LangChain use cases:
-- `Autonomous Agents <./use_cases/autonomous_agents.html>`_: Autonomous agents are long running agents that take many steps in an attempt to accomplish an objective. Examples include AutoGPT and BabyAGI.
+- `Autonomous Agents <./use_cases/autonomous_agents.html>`_: Autonomous agents are long-running agents that take many steps in an attempt to accomplish an objective. Examples include AutoGPT and BabyAGI.
-- `Agent Simulations <./use_cases/agent_simulations.html>`_: Putting agents in a sandbox and observing how they interact with each other or to events can be an interesting way to observe their long-term memory abilities.
+- `Agent Simulations <./use_cases/agent_simulations.html>`_: Putting agents in a sandbox and observing how they interact with each other and react to events can be an effective way to evaluate their long-range reasoning and planning abilities.
-- `Personal Assistants <./use_cases/personal_assistants.html>`_: The main LangChain use case. Personal assistants need to take actions, remember interactions, and have knowledge about your data.
+- `Personal Assistants <./use_cases/personal_assistants.html>`_: One of the primary LangChain use cases. Personal assistants need to take actions, remember interactions, and have knowledge about your data.
-- `Question Answering <./use_cases/question_answering.html>`_: The second big LangChain use case. Answering questions over specific documents, only utilizing the information in those documents to construct an answer.
+- `Question Answering <./use_cases/question_answering.html>`_: Another common LangChain use case. Answering questions over specific documents, only utilizing the information in those documents to construct an answer.
-- `Chatbots <./use_cases/chatbots.html>`_: Since language models are good at producing text, that makes them ideal for creating chatbots.
+- `Chatbots <./use_cases/chatbots.html>`_: Language models love to chat, making this a very natural use of them.
-- `Querying Tabular Data <./use_cases/tabular.html>`_: If you want to understand how to use LLMs to query data that is stored in a tabular format (csvs, SQL, dataframes, etc) you should read this page.
+- `Querying Tabular Data <./use_cases/tabular.html>`_: Recommended reading if you want to use language models to query structured data (CSVs, SQL, dataframes, etc).
-- `Code Understanding <./use_cases/code.html>`_: If you want to understand how to use LLMs to query source code from github, you should read this page.
+- `Code Understanding <./use_cases/code.html>`_: Recommended reading if you want to use language models to analyze code.
-- `Interacting with APIs <./use_cases/apis.html>`_: Enabling LLMs to interact with APIs is extremely powerful in order to give them more up-to-date information and allow them to take actions.
+- `Interacting with APIs <./use_cases/apis.html>`_: Enabling language models to interact with APIs is extremely powerful. It gives them access to up-to-date information and allows them to take actions.
- `Extraction <./use_cases/extraction.html>`_: Extract structured information from text.
-- `Summarization <./use_cases/summarization.html>`_: Summarizing longer documents into shorter, more condensed chunks of information. A type of Data Augmented Generation.
+- `Summarization <./use_cases/summarization.html>`_: Compressing longer documents. A type of Data-Augmented Generation.
-- `Evaluation <./use_cases/evaluation.html>`_: Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.
+- `Evaluation <./use_cases/evaluation.html>`_: Generative models are hard to evaluate with traditional metrics. One promising approach is to use language models themselves to do the evaluation.
.. toctree::
@@ -106,9 +107,9 @@ The above modules can be used in a variety of ways. LangChain also provides guid
:name: use_cases
:hidden:
- ./use_cases/personal_assistants.md
./use_cases/autonomous_agents.md
./use_cases/agent_simulations.md
+ ./use_cases/personal_assistants.md
./use_cases/question_answering.md
./use_cases/chatbots.md
./use_cases/tabular.rst
@@ -122,7 +123,7 @@ The above modules can be used in a variety of ways. LangChain also provides guid
Reference Docs
---------------
-All of LangChain's reference documentation, in one place. Full documentation on all methods, classes, installation methods, and integration setups for LangChain.
+| Full documentation on all methods, classes, installation methods, and integration setups for LangChain.
- `Reference Documentation <./reference.html>`_
@@ -140,7 +141,7 @@ All of LangChain's reference documentation, in one place. Full documentation on
LangChain Ecosystem
-------------------
-Guides for how other companies/products can be used with LangChain
+| Guides for how other companies/products can be used with LangChain.
- `LangChain Ecosystem <./ecosystem.html>`_
@@ -157,7 +158,7 @@ Guides for how other companies/products can be used with LangChain
Additional Resources
---------------------
-Additional collection of resources we think may be useful as you develop your application!
+| Additional resources we think may be useful as you develop your application!
- `LangChainHub `_: The LangChainHub is a place to share and explore other prompts, chains, and agents.