Low-Code AI Development with Prompt Chunking — Build Smarter AI Workflows

from langchain.text_splitter import RecursiveCharacterTextSplitter
from anthropic import Anthropic
import time

def process_large_document(document: str, task: str, model: str = "claude-sonnet-4-6") -> str:
    """
    Process a large document by chunking and combining AI results.

    Args:
        document: The full text content to process
        task: Instructions for what the AI should do with each chunk
        model: Claude model to use
    Returns:
        Combined final result from all chunks
    """

    # Split document into chunks with overlap
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=4000,        # ~4000 chars per chunk (roughly 1000-1500 tokens)
        chunk_overlap=400,      # 400-char overlap for context continuity between chunks
        separators=["

", "
", ". ", " ", ""]  # try largest split first
    )
    chunks = splitter.split_text(document)
    print(f"Split into {len(chunks)} chunks")

    client = Anthropic()
    results = []

    for i, chunk in enumerate(chunks):
        print(f"Processing chunk {i+1}/{len(chunks)}...")

        # Include previous results for context (last 2 only to avoid context overflow)
        context = ""
        if results:
            context = f"
Previous chunk results:
" + "
".join(results[-2:]) + "
"

        response = client.messages.create(
            model=model,
            max_tokens=1024,
            messages=[{
                "role": "user",
                "content": f"""Task: {task}

Document chunk {i+1} of {len(chunks)}:
{chunk}
{context}
Process this chunk according to the task. Be concise."""
            }]
        )
        results.append(response.content[0].text)
        time.sleep(0.5)  # Rate limiting between API calls

    # Final synthesis step — combine all chunk results
    print("Synthesizing final result...")
    synthesis = client.messages.create(
        model=model,
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Combine these chunk-by-chunk analyses into a single comprehensive result.
Remove duplicates. Maintain logical order.

Original task: {task}

Chunk analyses:
{chr(10).join(f'Chunk {i+1}: {r}' for i, r in enumerate(results))}

Provide the final combined result."""
        }]
    )

    return synthesis.content[0].text


# Usage examples:
result = process_large_document(
    document=open("large_report.txt").read(),
    task="Extract all key decisions and action items with responsible parties"
)

result2 = process_large_document(
    document=open("contract.pdf.txt").read(),
    task="Identify all obligations, deadlines, and penalty clauses"
)

print(result)

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_anthropic import ChatAnthropic
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

def build_rag_pipeline(documents: list[str]):
    """
    Build a retrieval-augmented generation pipeline.
    Chunks documents, embeds them, stores in vector DB.
    Then answers questions by retrieving relevant chunks.
    """

    # 1. Chunk all documents
    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
    all_chunks = []
    for doc in documents:
        all_chunks.extend(splitter.split_text(doc))
    print(f"Created {len(all_chunks)} total chunks from {len(documents)} documents")

    # 2. Embed chunks and store in vector database
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    vectorstore = Chroma.from_texts(all_chunks, embeddings)
    print("Vector store built")

    return vectorstore

def answer_question(vectorstore, question: str, k: int = 4) -> str:
    """Retrieve relevant chunks and answer the question."""

    # 3. Find most relevant chunks for the question
    relevant_chunks = vectorstore.similarity_search(question, k=k)
    context = "

".join([chunk.page_content for chunk in relevant_chunks])

    # 4. Ask Claude with the retrieved context
    client = Anthropic()
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Answer the question using only the provided context.
If the answer is not in the context, say so.

Context:
{context}

Question: {question}"""
        }]
    )
    return response.content[0].text