# Clone the repository
git clone https://github.com/WenyuChiou/awesome-agentic-ai-zh.git
cd awesome-agentic-ai-zh

# No additional dependencies for reading the roadmap
# Individual exercises may require Python and specific libraries

# Read the setup guide first
cat resources/setup-guide.md

# Install Python 3.8+ if needed
python --version

# Install common dependencies for exercises
pip install anthropic openai langchain chromadb

# Navigate Track A
cat tracks/cli/A1-cli-intro.md           # CLI agent comparison & setup
cat tracks/cli/A2-cli-workflow.md        # Workflow patterns
cat tracks/cli/A3-cli-production.md      # Production integration

# Key resource
cat resources/cli-agents-guide.md

# Navigate Track B
cat stages/03-tool-use-and-hello-agent.md    # Function calling, ReAct
cat stages/04-agent-frameworks.md             # LangGraph, AutoGen, CrewAI
cat stages/05-claude-code-ecosystem.md        # MCP, Skills, Plugins (SHARED HUB)
cat stages/06-memory-rag.md                   # Context engineering, RAG
cat stages/07-multi-agent-production.md       # Multi-agent orchestration
cat stages/07.5-advanced-agentic-concepts.md  # Advanced concepts (reading)
cat stages/08-agent-interfaces.md             # Computer Use, Browser Use (SHARED HUB)

# List all stage files
ls stages/

# View glossary of terms
cat resources/glossary.md

# Check CLI agents comparison
cat resources/cli-agents-guide.md

# Browse exercises
ls exercises/stage-*/

# Example: Stage 1 - First LLM API call
# exercises/stage-1/01-first-llm-call/main.py

import os
from anthropic import Anthropic

def main():
    client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
    
    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": "Explain AI agents in one sentence."}
        ]
    )
    
    print(message.content[0].text)

if __name__ == "__main__":
    main()

# Set up environment
export ANTHROPIC_API_KEY="your-key-here"

# Run exercise
python exercises/stage-1/01-first-llm-call/main.py

# Using Anthropic Claude
from anthropic import Anthropic

client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}]
)

# Using Ollama (local)
import ollama

response = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Hello"}]
)

# Set environment variables (recommended)
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."

# Or use .env file
cat > .env << EOF
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
EOF

# Load in Python
from dotenv import load_dotenv
load_dotenv()

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model
ollama pull llama3.2

# Test
ollama run llama3.2 "Explain what an AI agent is"

# For complete beginners
cat stages/00-foundations.md
# → Complete exercises in exercises/stage-0/

# Then proceed sequentially
cat stages/01-llm-basics.md
cat stages/02-prompt-engineering.md

# Choose your track
cat tracks/cli/A1-cli-intro.md    # OR
cat stages/03-tool-use-and-hello-agent.md

# Need MCP information?
cat stages/05-claude-code-ecosystem.md

# Need multi-agent patterns?
cat stages/07-multi-agent-production.md

# Need Computer Use examples?
cat stages/08-agent-interfaces.md

cat walkthroughs/build-first-agent-in-7-steps.md

# exercises/stage-3/02-function-calling/main.py
import os
import json
from anthropic import Anthropic

def get_weather(city: str) -> dict:
    """Mock weather API - returns fake data"""
    return {
        "city": city,
        "temperature": 22,
        "condition": "sunny"
    }

def main():
    client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
    
    tools = [{
        "name": "get_weather",
        "description": "Get current weather for a city",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
        }
    }]
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        tools=tools,
        messages=[
            {"role": "user", "content": "What's the weather in Tokyo?"}
        ]
    )
    
    # Handle tool use
    if response.stop_reason == "tool_use":
        tool_use = next(block for block in response.content if block.type == "tool_use")
        
        if tool_use.name == "get_weather":
            result = get_weather(**tool_use.input)
            
            # Send result back
            response = client.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=1024,
                tools=tools,
                messages=[
                    {"role": "user", "content": "What's the weather in Tokyo?"},
                    {"role": "assistant", "content": response.content},
                    {
                        "role": "user",
                        "content": [{
                            "type": "tool_result",
                            "tool_use_id": tool_use.id,
                            "content": json.dumps(result)
                        }]
                    }
                ]
            )
    
    print(response.content[0].text)

if __name__ == "__main__":
    main()

# exercises/stage-3/04-react-agent/main.py
import os
from anthropic import Anthropic

def search_papers(query: str) -> list:
    """Mock paper search"""
    return [
        {"title": "Attention Is All You Need", "year": 2017},
        {"title": "BERT: Pre-training of Deep Bidirectional Transformers", "year": 2018}
    ]

def summarize_paper(title: str) -> str:
    """Mock paper summarizer"""
    return f"Summary of '{title}': A foundational paper in NLP..."

def react_loop(user_query: str, max_iterations: int = 5):
    client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
    
    tools = [
        {
            "name": "search_papers",
            "description": "Search academic papers by query",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        },
        {
            "name": "summarize_paper",
            "description": "Get summary of a paper by title",
            "input_schema": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"}
                },
                "required": ["title"]
            }
        }
    ]
    
    messages = [{"role": "user", "content": user_query}]
    
    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=2048,
            tools=tools,
            messages=messages
        )
        
        messages.append({"role": "assistant", "content": response.content})
        
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        # Execute tools
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                if block.name == "search_papers":
                    result = search_papers(**block.input)
                elif block.name == "summarize_paper":
                    result = summarize_paper(**block.input)
                
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": str(result)
                })
        
        messages.append({"role": "user", "content": tool_results})
    
    return "Max iterations reached"

# Usage
result = react_loop("Find papers about transformers and summarize the most important one")
print(result)

# Example MCP server structure
# See stages/05-claude-code-ecosystem.md for details

from mcp.server import Server
from mcp.types import Tool, TextContent

app = Server("my-mcp-server")

@app.tool()
async def get_document(doc_id: str) -> str:
    """Fetch document by ID"""
    # Your implementation
    return f"Document content for {doc_id}"

@app.tool()
async def search_database(query: str) -> list:
    """Search internal database"""
    # Your implementation
    return [{"id": "1", "title": "Result"}]

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "my-server": {
      "command": "python",
      "args": ["/path/to/your/mcp_server.py"]
    }
  }
}

cat branches/for-researcher.md

cat branches/for-developer.md

cat branches/for-everyday-users.md

# Verify environment variable
echo $ANTHROPIC_API_KEY

# Set it if missing
export ANTHROPIC_API_KEY="sk-ant-..."

# Install required package
pip install anthropic

# For exercises requiring multiple packages
pip install -r requirements.txt

# Check if Ollama is running
curl http://localhost:11434/api/tags

# Start Ollama if needed
ollama serve

# Each stage has a glossary
cat resources/glossary.md

# Setup troubleshooting
cat resources/setup-guide.md

# CLI-specific issues
cat resources/cli-agents-guide.md

# Full glossary
cat resources/glossary.md

# Diagrams
ls resources/diagrams/
# - learning-map.png
# - branch-decision-tree.png
# - banner.png

# Complete setup guide
cat resources/setup-guide.md