LangChain

pip install langchain langchain-openai

import os
from langchain_openai import ChatOpenAI

# Set environment variables
os.environ["OPENAI_API_BASE"] = "https://api.yelinai.com/v1"
os.environ["OPENAI_API_KEY"] = "Your Laozhang API key"

# Initialize model
llm = ChatOpenAI(
    model="gpt-4-turbo",
    temperature=0.7,
    max_tokens=2000
)

# Test call
response = llm.invoke("Hello!")
print(response.content)

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# Create prompt template
prompt = PromptTemplate(
    input_variables=["product"],
    template="Please write an advertising slogan for {product}:"
)

# Create chain
chain = LLMChain(llm=llm, prompt=prompt)

# Execute chain
result = chain.run(product="AI programming assistant")
print(result)

from langchain.prompts import ChatPromptTemplate

# Multi-turn conversation template
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a professional {role}"),
    ("human", "{input}"),
])

# Format prompt
messages = prompt.format_messages(
    role="Python programmer",
    input="How to optimize code performance?"
)

# Call model
response = llm.invoke(messages)
print(response.content)

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Create memory
memory = ConversationBufferMemory()

# Create conversation chain
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# Multi-turn conversation
response1 = conversation.predict(input="My name is Zhang San")
response2 = conversation.predict(input="What's my name?")
print(response2)  # Will remember your name is Zhang San

from langchain.agents import initialize_agent, AgentType, Tool

# Define tools
tools = [
    Tool(
        name="Calculator",
        func=lambda x: eval(x),
        description="Useful for mathematical calculations"
    )
]

# Create agent
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Execute task
result = agent.run("What is (25 + 75) * 2?")
print(result)

from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA

# Load documents
loader = TextLoader("document.txt", encoding="utf-8")
documents = loader.load()

# Split text
text_splitter = CharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
texts = text_splitter.split_documents(documents)

# Create vector database
embeddings = OpenAIEmbeddings(
    openai_api_base="https://api.yelinai.com/v1",
    openai_api_key="Your Laozhang API key"
)
vectorstore = FAISS.from_documents(texts, embeddings)

# Create Q&A chain
qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

# Ask questions
result = qa.run("What is the main content of this document?")
print(result)

from langchain.chains import SimpleSequentialChain

# Step 1: Generate outline
outline_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=["topic"],
        template="Please create a detailed outline for the following topic:\n\n{topic}"
    )
)

# Step 2: Expand content
content_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=["outline"],
        template="Please expand the following outline into complete content:\n\n{outline}"
    )
)

# Combine chains
workflow = SimpleSequentialChain(
    chains=[outline_chain, content_chain],
    verbose=True
)

# Execute workflow
result = workflow.run("AI Application Development Guide")
print(result)

# Use GPT-3.5 for simple tasks (lower cost)
cheap_llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.5
)

# Use GPT-4 for complex tasks (higher quality)
expensive_llm = ChatOpenAI(
    model="gpt-4-turbo",
    temperature=0.7
)

# Simple classification task
classification = cheap_llm.invoke("Classify this text sentiment: This product is great!")

# Complex analysis task
analysis = expensive_llm.invoke("Please analyze this product review in depth: This product is great!")

from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

# Create model with streaming support
streaming_llm = ChatOpenAI(
    model="gpt-4-turbo",
    temperature=0.7,
    streaming=True,
    callbacks=[StreamingStdOutCallbackHandler()]
)

# Streaming response
response = streaming_llm.invoke("Please write a short story")

from langchain.tools import Tool

def search_database(query: str) -> str:
    """Search database"""
    # Your database search logic
    return f"Search result for: {query}"

# Create tool
search_tool = Tool(
    name="DatabaseSearch",
    func=search_database,
    description="Search information from database. Input should be search keywords."
)

from langchain.chains import LLMChain
from langchain.callbacks import get_openai_callback

try:
    with get_openai_callback() as cb:
        result = chain.run(input="Your input")
        print(f"Total tokens: {cb.total_tokens}")
        print(f"Total cost: \`$\{cb.total_cost}")
except Exception as e:
    print(f"Error occurred: {str(e)}")

from langchain.cache import InMemoryCache
import langchain

# Enable cache
langchain.llm_cache = InMemoryCache()

# First call (slower)
result1 = llm.invoke("What is AI?")

# Second call (use cache, faster)
result2 = llm.invoke("What is AI?")

# ❌ Bad example
prompt = "Write something"

# ✅ Good example
prompt = """
You are a professional technical writer.

Task: Write an article about AI applications
Requirements:
- Word count: 1000 words
- Audience: Technical professionals
- Style: Professional yet approachable
- Structure: Introduction - Body - Conclusion
- Include: 3 practical cases

Please start writing:
"""

# Set max_tokens
llm = ChatOpenAI(
    model="gpt-4-turbo",
    max_tokens=1000,  # Limit output length
    temperature=0.7
)

# Monitor token usage
with get_openai_callback() as cb:
    result = chain.run(input="Your input")
    print(f"Input tokens: {cb.prompt_tokens}")
    print(f"Output tokens: {cb.completion_tokens}")
    print(f"Total tokens: {cb.total_tokens}")

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10)
)
def call_llm_with_retry(input_text):
    return llm.invoke(input_text)

# Use retry function
result = call_llm_with_retry("Your input")

import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Use environment variables
api_key = os.getenv("OPENAI_API_KEY")
api_base = os.getenv("OPENAI_API_BASE")

# Do not hardcode API keys in code
llm = ChatOpenAI(
    openai_api_base=api_base,
    openai_api_key=api_key
)

from langchain.chains import LLMChain

# Create chain
chain = LLMChain(llm=llm, prompt=prompt)

# Batch processing
inputs = [
    {"product": "AI assistant"},
    {"product": "Smart home"},
    {"product": "Electric vehicle"}
]

results = chain.apply(inputs)
for result in results:
    print(result)

import asyncio
from langchain.callbacks import AsyncIteratorCallbackHandler

async def async_call():
    result = await llm.ainvoke("Hello!")
    return result

# Execute asynchronously
result = asyncio.run(async_call())