Tutorial: Run inference with Qwen3-Coder using W&B Inference

pip install openai wandb weave

# Set environment variables in your notebook
%env WANDB_API_KEY=your-wandb-api-key-here

export WANDB_API_KEY="your-wandb-api-key-here"

import os
# Set environment variables programmatically
os.environ["WANDB_API_KEY] = "your-wandb-api-key-here"

import os
from pathlib import Path
import openai
import weave

PROJECT = "wandb_inference"
weave.init(PROJECT)

MODEL = "Qwen/Qwen3-Coder-480B-A35B-Instruct"

client = openai.OpenAI(
    base_url="https://api.inference.wandb.ai/v1",
    api_key=os.getenv("WANDB_API_KEY"),
    project=PROJECT,
    default_headers={
        "OpenAI-Project": "wandb_fc/quickstart_playground"
    }
)

def extract_code(md: str) -> str:
    parts = md.split("```")
    if len(parts) == 1:
        return md
    for i in range(1, len(parts), 2):
        block = parts[i]
        if block.lower().startswith("python"):
            return block.split("\n", 1)[1]
        return block
    return md

def run_sorting_demo():
    out = Path("artifacts_sorting"); out.mkdir(exist_ok=True)
    prompt = (
        "Write a standalone Python module implementing merge sort with merge_sort(xs). "
        "Include a docstring explaining O(n log n) time and O(n) space. Add a __main__ demo. Return only code."
    )
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role":"system","content":"You are a senior Python engineer."},
            {"role":"user","content":prompt}
        ],
        temperature=0.2,
        max_tokens=1600,
    )
    code = extract_code(resp.choices[0].message.content)
    (out/"merge_sort.py").write_text(code, encoding="utf-8")
    print("Wrote", (out/"merge_sort.py").resolve())

if __name__ == "__main__":
    run_sorting_demo()

import os
from pathlib import Path
import textwrap
import openai
import weave

PROJECT = "wandb_inference"
MODEL = "Qwen/Qwen3-Coder-480B-A35B-Instruct"

weave.init(PROJECT)

client = openai.OpenAI(
    base_url="https://api.inference.wandb.ai/v1",
    api_key=os.getenv("WANDB_API_KEY"),
    project=PROJECT,
    default_headers={"OpenAI-Project": "wandb_fc/quickstart_playground"},
)

def write_demo_code(root: Path) -> None:
    src = root / "src"
    tests = root / "tests"
    src.mkdir(parents=True, exist_ok=True)
    tests.mkdir(parents=True, exist_ok=True)

    (src / "sorting.py").write_text(textwrap.dedent("""\
        \"\"\"Sorting utilities.\"\"\"

        from typing import List, TypeVar, Callable, Optional

        T = TypeVar("T")

        def merge_sort(items: List[T], key: Optional[Callable[[T], object]] = None) -> List[T]:
            \"\"\"Stable merge sort.

            Time: O(n log n)
            Space: O(n) auxiliary

            Args:
                items: list of values
                key: optional projection

            Returns:
                New sorted list.
            \"\"\"
            if key is None:
                key = lambda x: x

            def merge(left, right):
                out = []
                i = j = 0
                while i < len(left) and j < len(right):
                    if key(left[i]) <= key(right[j]):
                        out.append(left[i]); i += 1
                    else:
                        out.append(right[j]); j += 1
                out.extend(left[i:]); out.extend(right[j:])
                return out

            n = len(items)
            if n <= 1:
                return list(items)

            mid = n // 2
            left = merge_sort(items[:mid], key)
            right = merge_sort(items[mid:], key)
            return merge(left, right)
    """), encoding="utf-8")

    (src / "search.py").write_text(textwrap.dedent("""\
        \"\"\"Search utilities.\"\"\"

        from typing import Sequence, TypeVar, Callable, Optional

        T = TypeVar("T")

        def binary_search(seq: Sequence[T], target: T, key: Optional[Callable[[T], object]] = None) -> int:
            \"\"\"Return index of target in a sorted sequence or -1 if not found.\"\"\"
            if key is None:
                key = lambda x: x
            lo, hi = 0, len(seq) - 1
            while lo <= hi:
                mid = (lo + hi) // 2
                kmid = key(seq[mid])
                if kmid == key(target):
                    return mid
                if kmid < key(target):
                    lo = mid + 1
                else:
                    hi = mid - 1
            return -1
    """), encoding="utf-8")

    (src / "buggy.py").write_text(textwrap.dedent("""\
        \"\"\"A tiny bug for the docs debugging section.\"\"\"

        def reverse_string(s: str) -> str:
            \"\"\"Return the reverse of s.

            Intentional bug: slice step is 1 instead of -1.
            \"\"\"
            return s[::1]  # bug
    """), encoding="utf-8")

    (src / "app.py").write_text(textwrap.dedent("""\
        \"\"\"CLI-free demo runner.\"\"\"
        from sorting import merge_sort
        from search import binary_search
        from buggy import reverse_string

        def run_demo() -> dict:
            data = [5, 2, 9, 1, 5, 6]
            sorted_data = merge_sort(data)
            idx_of_5 = binary_search(sorted_data, 5)
            buggy = reverse_string("weave")
            return {
                "input": data,
                "sorted": sorted_data,
                "index_of_5": idx_of_5,
                "reverse_bug": buggy,
            }

        if __name__ == "__main__":
            print(run_demo())
    """), encoding="utf-8")

    (tests / "test_sorting.py").write_text(textwrap.dedent("""\
        from src.sorting import merge_sort

        def test_merge_sort_basic():
            assert merge_sort([3,1,2]) == [1,2,3]

        def test_merge_sort_stability():
            items = [("a",1),("b",1),("c",0)]
            out = merge_sort(items, key=lambda x: x[1])
            assert out == [("c",0),("a",1),("b",1)]
    """), encoding="utf-8")

def collect_context(root: Path) -> str:
    files = [
        root / "src" / "sorting.py",
        root / "src" / "search.py",
        root / "src" / "buggy.py",
        root / "src" / "app.py",
        root / "tests" / "test_sorting.py",
    ]
    parts = []
    for p in files:
        try:
            txt = p.read_text(encoding="utf-8")
        except Exception:
            txt = ""
        header = f"\nFile: {p.as_posix()}\n"
        snippet = txt.strip()
        if len(snippet) > 1200:
            snippet = snippet[:1200]
        parts.append(header + snippet)
    return "\n".join(parts)

def run_docs_demo():
    out = Path("artifacts_docs")
    out.mkdir(exist_ok=True)

    write_demo_code(out)
    code_context = collect_context(out)

    project_context = textwrap.dedent("""\
        Project name
        Personal Tools Demo

        Summary
        This repo contains a small Python package with merge sort, binary search, and a deliberately buggy reverse function. 
        A simple runner shows usage. Tests cover sorting.
    """).strip()

    prompt = f"""
Write a README with plain headers only.
Sections: Title, Overview, Setup, How to Run, Code Tour, Complexity, Testing, Debugging Notes, Outputs, Notes.
Explain merge sort complexity as O(n log n) and note O(n) auxiliary space.
Avoid lists, bold, italics, double hyphens, and words like critical or essential.
Describe the included files and what they do.
Include a short note that reverse_string has a slice bug and how to fix it by changing s[::1] to s[::-1].
Context
{project_context}

Code
{code_context}
""".strip()

    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": "You write clear technical READMEs."},
            {"role": "user", "content": prompt},
        ],
        temperature=0.2,
        max_tokens=1400,
    )
    text = resp.choices[0].message.content
    (out / "README.md").write_text(text, encoding="utf-8")
    print("Wrote", (out / "README.md").resolve())
    print("Wrote code under", out.resolve())

if __name__ == "__main__":
    run_docs_demo()

import io
import requests
import openai
import weave
from pypdf import PdfReader
import os


PROJECT = "wandb_inference"
weave.init(PROJECT)


PDF_URL = "https://docs.aws.amazon.com/pdfs/bedrock-agentcore/latest/devguide/bedrock-agentcore-dg.pdf"
QUESTION = "Summarize how AgentCore's memory architecture functions and when to use it."


client = openai.OpenAI(
    base_url="https://api.inference.wandb.ai/v1",
    api_key=os.getenv("WANDB_API_KEY"),
    project=PROJECT,
    default_headers={
        "OpenAI-Project": "wandb_fc/quickstart_playground"  # replace with your actual team/project
    }
)


r = requests.get(PDF_URL, timeout=60)
r.raise_for_status()


reader = PdfReader(io.BytesIO(r.content))
pages = reader.pages[:100]
text = "\n\n".join(page.extract_text() or "" for page in pages)


doc_snippet = text


prompt = (
    f"Using the provided AWS Bedrock AgentCore doc, answer: {QUESTION}\n\n"
    f"Documentation:\n{doc_snippet}\n\n"
    "Cite quotes where relevant."
)


resp = client.chat.completions.create(
    model="Qwen/Qwen3-Coder-480B-A35B-Instruct",
    messages=[
        {"role": "system", "content": "You analyze the given text only. If info is missing, say so."},
        {"role": "user", "content": prompt}
    ],
    temperature=0.25,
    max_tokens=1400,
)


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


import openai
import wandb
import weave
from weave import Content

# Init weave
PROJECT = "wandb_inference"
weave.init(PROJECT)

# Configure OpenAI client with W&B Inference
client = openai.OpenAI(
    base_url="https://api.inference.wandb.ai/v1",
    api_key=wandb.api.api_key,
    project=PROJECT,
    default_headers={
        "OpenAI-Project": "wandb_fc/quickstart_playground"
    }
)

MODEL = "Qwen/Qwen3-Coder-480B-A35B-Instruct"

def write_html_file(html_text: str, out_dir="site_output", filename="index.html") -> str:
    out = Path(out_dir)
    out.mkdir(exist_ok=True)
    path = out / filename
    path.write_text(html_text, encoding="utf-8")
    return str(path.resolve())

@weave.op
def generate_html(prompt: str) -> Annotated[str, Content[Literal["html"]]]:
    request = f"""
    You are a front-end web developer.
    Generate a single self-contained HTML file named index.html.
    Put all CSS in a <style> tag and all JS in a <script> tag.
    Use semantic HTML, a sticky header, hero section, projects grid, and a contact form with client-side validation.
    Plain CSS and vanilla JS only. No external CDNs or assets.
    Demonstrate: "{prompt}".
    Return only the HTML source, no explanations, no code fences, no extra text.
    """
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "system", "content": request}],
        temperature=0.3,
        max_tokens=3500,
    )
    html_text = resp.choices[0].message.content.strip()
    write_html_file(html_text)
    return html_text.encode("utf-8")

if __name__ == "__main__":
    site_request = "A playful portfolio page styled like Windows 95 with a projects grid and contact form"
    result = generate_html(site_request)
    print("HTML logged to Weave and written to site_output/index.html")