Integrate AI Models in Godot 4.5 with GDScript in 20 Minutes

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Pull a small but capable model
ollama pull llama3.2:3b

# Start the server (runs on localhost:11434)
ollama serve

extends Node
class_name AIManager

# HTTPRequest node for API calls
var http_request: HTTPRequest

# Store callbacks for async responses
var pending_requests: Dictionary = {}

func _ready() -> void:
    http_request = HTTPRequest.new()
    add_child(http_request)
    # Connect to response handler
    http_request.request_completed.connect(_on_request_completed)

func query_llm(prompt: String, callback: Callable) -> void:
    """Send prompt to local LLM and call callback with response"""
    var url = "http://localhost:11434/api/generate"
    var headers = ["Content-Type: application/json"]
    
    var body = JSON.stringify({
        "model": "llama3.2:3b",
        "prompt": prompt,
        "stream": false  # Get complete response at once
    })
    
    # Store callback with unique ID
    var request_id = Time.get_ticks_msec()
    pending_requests[request_id] = callback
    
    # Make async request - won't freeze game
    var error = http_request.request(url, headers, HTTPClient.METHOD_POST, body)
    
    if error != OK:
        push_error("HTTP Request failed: " + str(error))
        callback.call("")

func _on_request_completed(result: int, response_code: int, headers: PackedStringArray, body: PackedByteArray) -> void:
    """Handle AI model response"""
    if response_code != 200:
        push_error("API returned code: " + str(response_code))
        return
    
    var json = JSON.parse_string(body.get_string_from_utf8())
    
    if json and "response" in json:
        var ai_text = json["response"]
        # Call the stored callback
        if pending_requests.size() > 0:
            var callback = pending_requests.values()[0]
            pending_requests.clear()
            callback.call(ai_text)
    else:
        push_error("Invalid JSON response from AI")

extends CharacterBody2D
class_name NPCCharacter

@onready var ai_manager: AIManager = get_node("/root/AIManager")
@onready var dialogue_label: Label = $DialogueLabel

# NPC personality and context
var npc_context: String = """You are Grok, a mysterious merchant in a fantasy RPG. 
You speak in riddles and offer cryptic advice about the player's quest. 
Keep responses under 40 words."""

var is_talking: bool = false

func _ready() -> void:
    dialogue_label.hide()

func talk_to_player(player_message: String) -> void:
    """Generate AI response to player input"""
    if is_talking:
        return  # Prevent spam clicking
    
    is_talking = true
    dialogue_label.text = "Thinking..."
    dialogue_label.show()
    
    # Build prompt with context
    var full_prompt = npc_context + "\n\nPlayer: " + player_message + "\n\nGrok:"
    
    # Request AI response
    ai_manager.query_llm(full_prompt, _on_ai_response)

func _on_ai_response(ai_text: String) -> void:
    """Display AI-generated dialogue"""
    is_talking = false
    
    if ai_text.is_empty():
        dialogue_label.text = "..."
        await get_tree().create_timer(2.0).timeout
        dialogue_label.hide()
        return
    
    # Clean up response
    ai_text = ai_text.strip_edges()
    dialogue_label.text = ai_text
    
    # Auto-hide after reading time
    await get_tree().create_timer(5.0).timeout
    dialogue_label.hide()

func _input(event: InputEvent) -> void:
    """Interact when player presses E near NPC"""
    if event.is_action_pressed("ui_accept") and player_nearby():
        talk_to_player("Tell me about the ancient ruins.")

# In ai_manager.gd
func query_llm(prompt: String, callback: Callable, options: Dictionary = {}) -> void:
    var body = JSON.stringify({
        "model": "llama3.2:3b",
        "prompt": prompt,
        "stream": false,
        "options": {
            "num_predict": 50,  # Limit response length
            "temperature": 0.7,  # Lower = more predictable
            "top_p": 0.9
        }
    })
    # ... rest of function

# Terminal 1: Start Ollama
ollama serve

# Terminal 2: Check API works
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "Say hello in 5 words",
  "stream": false
}'

# Add to ai_manager.gd
func analyze_image(image_path: String, question: String, callback: Callable) -> void:
    """Use vision model to analyze screenshots or textures"""
    var url = "http://localhost:11434/api/generate"
    var headers = ["Content-Type: application/json"]
    
    # Load and encode image
    var image = Image.load_from_file(image_path)
    var buffer = image.save_png_to_buffer()
    var base64_image = Marshalls.raw_to_base64(buffer)
    
    var body = JSON.stringify({
        "model": "llava:7b",  # Vision-language model
        "prompt": question,
        "images": [base64_image],
        "stream": false
    })
    
    pending_requests[Time.get_ticks_msec()] = callback
    http_request.request(url, headers, HTTPClient.METHOD_POST, body)

# Usage example:
func identify_item(screenshot_path: String) -> void:
    ai_manager.analyze_image(
        screenshot_path,
        "What fantasy item is in this image? Name it in 3 words.",
        func(result): print("Item identified: ", result)
    )

ollama pull llava:7b

func query_with_fallback(prompt: String, callback: Callable) -> void:
    # Try local first
    query_llm(prompt, func(response):
        if response.is_empty():
            # Fall back to cloud
            query_cloud_api(prompt, callback)
        else:
            callback.call(response)
    )