Introduction to Large Language Models (LLMs)

# Simplified LLM prediction process
def generate_response(prompt):
    """
    LLMs predict one token (word piece) at a time
    """
    tokens = tokenize(prompt)  # "Hello world" → ["Hello", " world"]
    
    # Start with user's prompt
    generated_tokens = tokens
    
    # Generate 50 new tokens
    for _ in range(50):
        # Predict next token based on context
        next_token = model.predict_next_token(generated_tokens)
        generated_tokens.append(next_token)
        
        # Stop if we generate end token
        if next_token == "":
            break
    
    return detokenize(generated_tokens)

# Example
prompt = "The capital of France is"
response = generate_response(prompt)
print(response)
# Output: "The capital of France is Paris, a beautiful city 
#          known for the Eiffel Tower..."

# Install: pip install openai
from openai import OpenAI

client = OpenAI(api_key="your-api-key")

# Simple completion
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to calculate fibonacci"}
    ],
    temperature=0.7,  # Creativity (0-2)
    max_tokens=500    # Response length limit
)

print(response.choices[0].message.content)

# Streaming response (like ChatGPT typing effect)
stream = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Tell me a story"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

# Install: pip install transformers torch
from transformers import pipeline

# Load a pre-trained model
generator = pipeline('text-generation', model='gpt2')

# Generate text
result = generator(
    "Once upon a time",
    max_length=100,
    num_return_sequences=1
)

print(result[0]['generated_text'])

# Different tasks
summarizer = pipeline("summarization")
translator = pipeline("translation_en_to_fr")
sentiment = pipeline("sentiment-analysis")

# Use them
summary = summarizer("Long article text here...", max_length=50)
french = translator("Hello, how are you?")
feeling = sentiment("I love this product!")

# Install: pip install langchain openai
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain

# Create chat model
llm = ChatOpenAI(model="gpt-4", temperature=0.7)

# Create prompt template
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a {profession}. Be helpful and professional."),
    ("user", "{question}")
])

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

# Use it
response = chain.run(
    profession="Python expert",
    question="How do I read a CSV file?"
)

print(response)

# simple_chatbot.py
from openai import OpenAI
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def chat():
    """Simple chatbot with conversation history"""
    messages = [
        {"role": "system", "content": "You are a friendly AI assistant."}
    ]
    
    print("Chatbot ready! (Type 'quit' to exit)")
    print("-" * 50)
    
    while True:
        # Get user input
        user_input = input("You: ")
        
        if user_input.lower() == 'quit':
            print("Bot: Goodbye!")
            break
        
        # Add user message to history
        messages.append({"role": "user", "content": user_input})
        
        # Get AI response
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=messages,
            temperature=0.7,
            max_tokens=500
        )
        
        # Extract and display response
        bot_message = response.choices[0].message.content
        print(f"Bot: {bot_message}\n")
        
        # Add bot response to history (for context)
        messages.append({"role": "assistant", "content": bot_message})
        
        # Show token usage
        print(f"(Tokens used: {response.usage.total_tokens})")

if __name__ == "__main__":
    chat()