텍스트 분할기와 임베딩

When working with large documents, directly feeding them to a Large Language Model (LLM) often causes problems. LLMs have strict input limits, known as context windows.

This lesson teaches you how to prepare large texts for LLMs using two key techniques: text splitting and embeddings. These are essential for building advanced AI agents.

Imagine you have a 100-page PDF document. If you try to ask an LLM a question about it, you can't just send the whole document.

• Context Window Limits: LLMs can only process a certain amount of text at once (e.g., 4,000 to 128,000 tokens).
• Cost: Longer inputs mean higher API costs.
• Relevance: Filling the context window with irrelevant information can make the LLM 'forget' the important parts.

Text splitting solves this by breaking documents into smaller, manageable chunks.

LangChain provides various text splitters to divide documents efficiently. Their goal is to keep semantically related pieces of text together while respecting size limits.

Instead of just cutting at arbitrary character counts, smart splitters try to break text at logical points, like paragraphs or sentences.

A common and versatile splitter is the RecursiveCharacterTextSplitter.

The RecursiveCharacterTextSplitter is a powerful tool. It attempts to split text using a list of characters, trying them in order until the chunks are small enough.

• It starts by trying to split by \n\n (double newline for paragraphs).
• If chunks are still too big, it tries \n (single newline for lines).
• Then spaces, and finally individual characters.

This recursive approach helps maintain semantic coherence.

Let's see how RecursiveCharacterTextSplitter works. We'll split a short story into chunks.

Two crucial parameters for text splitting are chunk_size and chunk_overlap:

• Chunk Size: This is the maximum number of characters (or tokens, depending on the splitter) in each chunk. Choose a size that fits within your LLM's context window.
• Chunk Overlap: This specifies how many characters (or tokens) should overlap between consecutive chunks. Overlap helps preserve context across splits, ensuring that important information isn't lost at chunk boundaries.

Finding the right balance for these parameters is key to effective retrieval.

Let's modify our previous example to use a chunk_overlap. Notice how parts of the text are repeated in adjacent chunks, providing continuity.

Once you've split your documents, how do you find the most relevant chunks for a user's query? This is where text embeddings come in.

• An embedding is a numerical representation (a vector) of text.
• Texts with similar meanings have embeddings that are 'closer' to each other in a high-dimensional space.
• This allows us to perform semantic search: finding chunks that are conceptually similar to a query, not just keyword matches.

Embeddings are the backbone of Retrieval Augmented Generation (RAG).

LangChain makes it easy to generate embeddings using various models. You interact with an Embeddings object, which abstracts away the underlying model details.

Popular embedding models include those from OpenAI, Hugging Face, Cohere, and many open-source options like `all-MiniLM-L6-v2`.

You typically initialize an embedding model and then call its embed_query() for a single text or embed_documents() for a list of chunks.

Here's how to generate an embedding for a simple text using OpenAI's embedding model. Remember, you'll need an OpenAI API key for this to run successfully.

Consider the following statements about text splitting and embeddings:

You've learned two fundamental techniques for handling large documents in AI agents:

• Text Splitting: Breaking large texts into smaller, manageable chunks using tools like RecursiveCharacterTextSplitter, controlled by chunk_size and chunk_overlap.
• Embeddings: Converting text chunks into numerical vectors using embedding models (e.g., OpenAIEmbeddings) to enable semantic similarity search.

These techniques are crucial for building effective Retrieval Augmented Generation (RAG) systems, allowing your agents to intelligently find and use relevant information from vast knowledge bases.