Starter material

Implementation Samples

Start from one complete deployment reference and five technique scaffolds. Use the examples to learn the pattern, then adapt the idea for your own team.

Use template repository Technique catalog

The template includes the minimal FastAPI app plus standalone technique folders for agents, embeddings, vision, streaming, and evaluation. Never put real Azure credentials in team repositories.

5 techniques + 1 worked example

Pick a Track and Open the Deep-Dive

Time-bounded build paths →

Each deep-dive has the problem, users, architecture, prompt pack, pattern snippet, demo screens, budget note, and pitfalls. Career CV is the complete deployment anchor; the other five are technique showcases.

Basic reference

CV Feedback Bot

The complete worked example: JSON-mode structured output, privacy guardrails, and deployable Azure Container Apps path.

Open deep-dive
Agent orchestration

Multi-step Service Triage Agent

A tool-calling pattern that chooses FAQ lookup or human escalation instead of answering everything directly.

Open deep-dive
Embeddings

Skill-Matched Recommender

A local-vector scaffold that can later switch to Azure embeddings without requiring Azure AI Search.

Open deep-dive
Multimodal vision

Document Vision Reader

Use gpt-4o-mini image input to extract structured fields from a form, screenshot, or poster.

Open deep-dive
Streaming

Real-time Streaming Chat

A token-streaming pattern for demos where perceived responsiveness matters.

Open deep-dive
Evaluation

Evaluation Harness

A lightweight rubric and test-case loop that helps teams improve prompts with evidence.

Open deep-dive

Template Workflow

1

Use template

Open halla-ai/hackathon-sample-2026 and create your own team repository from the template.

2

Set `.env` locally

Copy `.env.example` to `.env` and fill only the values provided by tutors or operations.

3

Run mock mode first

Build the UI and README before spending Azure tokens on repeated tests.

4

Add your project context

Replace the sample context with a short public or synthetic dataset.

5

Show Azure use clearly

In the demo, explain the Foundry project, model call, and safety limits without exposing secrets.

Copy-ready Prompts

Problem framing prompt

We are a KOICA-TIU hackathon team. Help us turn this idea into one clear user, one problem, one demo screen, and one Azure AI workflow. Keep the scope small enough for one day.

System prompt starter

You are an assistant for a student demo. Answer only from the provided context. If the context does not contain enough information, say what is missing. Do not invent facts.

Demo rehearsal prompt

Review our 3-minute demo plan. Identify the riskiest step, one backup option, and one sentence that explains how Azure or Foundry is used.

Tutor review prompt

Act as our tutor. Check whether our project has one clear user, a small data source, a working model call, no exposed secrets, and a demo that can run in 3 minutes.

Cost reduction prompt

Review this prototype flow and suggest how to reduce Azure token use, repeated model calls, and unnecessary app runtime without weakening the demo.

Slide outline prompt

Create a 5-slide hackathon presentation outline: problem, user, solution, Azure workflow, demo result and next step. Keep each slide short.

Minimal Azure OpenAI Client

This sample keeps secrets in environment variables and uses a narrow system prompt. Tutors will provide the correct endpoint and deployment names for assigned teams. 

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    api_version="2024-12-01-preview",
)

SYSTEM_PROMPT = """
You are a helpful assistant for a KOICA-TIU hackathon team.
Answer only from the provided context. If the context is missing,
say what information is needed.
"""

def answer_question(question: str, context: str) -> str:
    response = client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {question}"},
        ],
        temperature=0.2,
        max_tokens=500,
    )
    return response.choices[0].message.content or ""

Tiny API Wrapper

A small API is enough for most hackathon demos. Keep the context short and public or synthetic. 

import os
from fastapi import FastAPI
from pydantic import BaseModel

from ai_client import answer_question

APP_CONTEXT = """
Replace this with a short public or synthetic document set.
Example: hackathon FAQ, role descriptions, sample rubric,
or a small synthetic document screenshot summary.
"""

app = FastAPI(title="KOICA-TIU Hackathon Demo")

class Question(BaseModel):
    text: str

@app.post("/ask")
def ask(payload: Question):
    return {
        "answer": answer_question(payload.text, APP_CONTEXT),
        "scope": "hackathon-demo",
    }

README Template

Every team should submit a short README so judges can understand the project even if the live demo fails. 

# Project title

## Problem
One sentence describing the Uzbekistan problem this project solves.

## Users
Who will use it, and in what situation?

## Azure resources
- Microsoft Foundry project:
- Model deployment:
- App Service slot:

## Team roles
- PM/domain:
- Prompt/data:
- Foundry/backend:
- Frontend/demo:

## Demo flow
1. Open the app.
2. Ask the prepared demo question.
3. Show the answer and explain the source/context.
4. Explain limitations and next steps.

## Safety
- No private personal data.
- No API keys or passwords in the repository.
- Backup screenshot or video prepared.

Demo Checklist

One clear problem
One prepared demo question
One visible Azure/Foundry component
No secrets on screen
Backup screenshot or video
Known limitation explained