Racket

racket hello.rkt
raco pkg install <package>

#lang racket
(define name "Ada")
(printf "Hello, AI! Welcome to Racket, ~a.\n" name)

#lang racket
(define layers 32)
(define model "llama3.1")
(define (fp16-gb params) (/ (* params 2) 1e9))
(printf "~a: ~a layers, ~a GB\n" model layers (fp16-gb 8.03e9))
(displayln (string-upcase model))

#lang racket
(define vram '(("H100" . 80) ("H200" . 141) ("RTX 5090" . 32)))
(displayln (map car (filter (λ (p) (>= (cdr p) 80)) vram)))
(displayln (foldl + 0 (map cdr vram)))
(displayln (for/list ([i (in-range 1 6)]) (* i i)))
(displayln (for/sum ([i (in-range 1 11)]) i))

#lang racket
(struct gpu (name vram) #:transparent)

(define (describe g)
  (match g
    [(gpu name v) #:when (>= v 80) (format "data center GPU ~a" name)]
    [(gpu name v) (format "GPU ~a (~a GB)" name v)]))

(for ([g (list (gpu "H100" 80) (gpu "RTX 5090" 32))])
  (displayln (describe g)))

#lang racket
(define counts (make-hash))
(for ([w (string-split (string-downcase (file->string "notes.txt")))])
  (hash-update! counts w add1 0))
(define top (take (sort (hash->list counts) > #:key cdr) 5))
(for ([p top]) (printf "~a ~a\n" (car p) (cdr p)))

#lang racket
(define-syntax-rule (repeat n body ...)
  (for ([_ (in-range n)]) body ...))

(repeat 3 (displayln "training step"))

(define-syntax-rule (unless-zero x expr)
  (if (zero? x) 'skipped expr))
(displayln (unless-zero 0 (/ 1 0)))   ; skipped, no division error

#lang racket
(define xs (for/list ([i 100]) (+ -1.0 (* 2.0 (/ i 99)))))
(define ys (map (λ (x) (+ (* 3 x) 0.5)) xs))
(define n (length xs))

(define (step wb _)
  (match-define (cons w b) wb)
  (define errs (map (λ (x y) (- (+ (* w x) b) y)) xs ys))
  (define gw (/ (* 2 (apply + (map * errs xs))) n))
  (define gb (/ (* 2 (apply + errs)) n))
  (cons (- w (* 0.1 gw)) (- b (* 0.1 gb))))

(displayln (foldl (λ (i wb) (step wb i)) (cons 0.0 0.0) (range 500)))

#lang racket
;; raco pkg install http-easy
(require net/http-easy json)

(define url "http://localhost:11434/v1/chat/completions")
(define tools
  (list (hasheq 'type "function"
                'function (hasheq 'name "get_weather" 'description "Weather for a city"
                                  'parameters (hasheq 'type "object"
                                                      'properties (hasheq 'city (hasheq 'type "string"))
                                                      'required '("city"))))))
(define impls (hash "get_weather" (λ (args) (format "It is 24°C and sunny in ~a." (hash-ref args 'city)))))

(define (chat messages)
  (define res (post url #:json (hasheq 'model "llama3.1" 'messages messages 'tools tools)))
  (hash-ref (first (hash-ref (response-json res) 'choices)) 'message))

(let loop ([messages (list (hasheq 'role "user" 'content "Should I take an umbrella in Lahore today?"))]
           [n 5])
  (define msg (chat messages))
  (define calls (hash-ref msg 'tool_calls '()))
  (if (or (zero? n) (null? calls) (eq? calls 'null))
      (displayln (hash-ref msg 'content))
      (loop (append messages (list msg)
                    (for/list ([c calls])
                      (define f (hash-ref c 'function))
                      (hasheq 'role "tool" 'tool_call_id (hash-ref c 'id)
                              'content ((hash-ref impls (hash-ref f 'name))
                                        (string->jsexpr (hash-ref f 'arguments))))))
            (sub1 n))))