LLM Application Frameworks

LangChain

Most popular framework for LLM apps

from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationBufferMemory

# 1. Simple chain
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

prompt = PromptTemplate(
    input_variables=["product"],
    template="Write a creative ad for {product}:"
)

chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run(product="eco-friendly water bottle")

# 2. Chain with memory (chatbot)
memory = ConversationBufferMemory()

conversation = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=["history", "input"],
        template="""
        Previous conversation:
        {history}
        
        Human: {input}
        AI:
        """
    ),
    memory=memory
)

# Multi-turn conversation
conversation.run("Hi, I'm looking for a laptop")
# "Hello! I'd be happy to help you find a laptop..."

conversation.run("What's the best for programming?")
# "For programming, I'd recommend..." (remembers context)

# 3. Agents with tools
from langchain.agents import create_openai_functions_agent, AgentExecutor
from langchain.tools import Tool

def search_products(query: str) -> str:
    # Mock product search
    return f"Found 3 products matching '{query}'"

def check_inventory(product_id: str) -> str:
    return f"Product {product_id}: In stock (5 units)"

tools = [
    Tool(name="Search", func=search_products, 
         description="Search for products"),
    Tool(name="Inventory", func=check_inventory,
         description="Check inventory for product")
]

agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools)

result = agent_executor.invoke({
    "input": "Find me a laptop and check if it's in stock"
})

# Agent decides:
# 1. Use Search tool → "laptop"
# 2. Use Inventory tool → product ID from search
# 3. Return combined answer

LlamaIndex

Specialized for RAG and data indexing

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI

# 1. Load and index documents
documents = SimpleDirectoryReader("./data").load_data()

# Create index (auto-chunks and embeds)
index = VectorStoreIndex.from_documents(documents)

# 2. Query
query_engine = index.as_query_engine()
response = query_engine.query("What is the vacation policy?")
print(response)

# 3. Advanced: Custom chunking
from llama_index.core.node_parser import SentenceSplitter

parser = SentenceSplitter(chunk_size=512, chunk_overlap=50)
nodes = parser.get_nodes_from_documents(documents)

index = VectorStoreIndex(nodes)

# 4. Multiple data sources
from llama_index.core import StorageContext
from llama_index.vector_stores.pinecone import PineconeVectorStore

# Connect to Pinecone
vector_store = PineconeVectorStore(...)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Index to Pinecone
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context
)

Function Calling / Tool Use

Give LLMs ability to call external functions

# OpenAI function calling
functions = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City name, e.g., San Francisco"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"]
                }
            },
            "required": ["location"]
        }
    },
    {
        "name": "search_database",
        "description": "Search company database",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"}
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "What's the weather in Tokyo?"}
    ],
    functions=functions,
    function_call="auto"  # Let model decide
)

# Model returns function call
function_call = response.choices[0].message.function_call

if function_call.name == "get_weather":
    args = json.loads(function_call.arguments)
    # {"location": "Tokyo", "unit": "celsius"}
    
    # Execute function
    weather = get_weather(**args)
    
    # Send result back to model
    second_response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "user", "content": "What's the weather in Tokyo?"},
            response.choices[0].message,
            {
                "role": "function",
                "name": "get_weather",
                "content": json.dumps(weather)
            }
        ]
    )
    
    print(second_response.choices[0].message.content)
    # "The current weather in Tokyo is 22°C with clear skies."

Multi-Agent Systems

Multiple specialized agents collaborating

from langchain.agents import AgentType, initialize_agent

# Agent 1: Research specialist
research_agent = initialize_agent(
    tools=[web_search_tool, wikipedia_tool],
    llm=llm,
    agent=AgentType.OPENAI_FUNCTIONS,
    verbose=True
)

# Agent 2: Writer specialist
writer_agent = initialize_agent(
    tools=[grammar_check_tool, style_guide_tool],
    llm=llm,
    agent=AgentType.OPENAI_FUNCTIONS,
    verbose=True
)

# Orchestrator
def multi_agent_workflow(topic):
    # Step 1: Research agent gathers info
    research = research_agent.run(f"Research {topic}")
    
    # Step 2: Writer agent creates content
    article = writer_agent.run(
        f"Write an article about {topic} based on: {research}"
    )
    
    return article

result = multi_agent_workflow("quantum computing")

Framework Comparison

Framework	Best For	Learning Curve	Community
LangChain	General LLM apps, agents	Medium	Largest
LlamaIndex	RAG, data indexing	Low	Large
Haystack	Search, RAG	Medium	Medium
Semantic Kernel	.NET integration	Medium	Growing
AutoGen	Multi-agent systems	High	Growing