DEV Community: Murni Marcus

Open-Sourcing Our Game AI Stack — SDKs, Templates, and CLI Tools for NPC Dialogue

Murni Marcus — Mon, 25 May 2026 04:22:33 +0000

Open-Sourcing Our Game AI Stack

At Vantage Digital Labs, we've been building AI-powered NPC dialogue systems for games. Most of our internal tooling is now stable enough to share. We're releasing everything as open source — SDKs, starter templates, and CLI debugging tools.

Here's what's in each repo and how to get started.

The Repos

We maintain code across two GitHub accounts:

Organization (vantage-digital-labs) — Production SDKs:

core-sdk — Node.js / Browser SDK
unity-sdk — Unity C# SDK
unreal-plugin — Unreal Engine 5 C++ plugin

Personal (maximilian32541-spec) — Developer tools:

npc-dialogue-starter — Template project
game-ai-utils — CLI debugging tools

core-sdk — The Foundation

The core SDK is a TypeScript client that talks to our inference API. It handles NPC chat, streaming responses, voice synthesis, and session memory.

const { VantageClient } = require('@vantage-labs/core-sdk');

const client = new VantageClient({
  apiKey: 'vk_live_your_key_here',
  region: 'asia-northeast1'
});

// Basic NPC chat
const response = await client.npc.chat({
  npcId: 'npc_blacksmith_01',
  playerId: 'player_abc',
  message: 'Can you repair my sword?',
  context: {
    playerGold: 150,
    reputation: 'friendly',
    timeOfDay: 'evening'
  }
});

console.log(response.dialogue);  // "Aye, I can fix that. 50 gold."
console.log(response.emotion);   // "helpful"

For real-time dialogue, use WebSocket streaming:

const ws = client.npc.stream({
  npcId: 'npc_guard_01',
  playerId: 'player_abc'
});

ws.on('dialogue_chunk', (chunk) => {
  process.stdout.write(chunk.text);  // Display as it generates
});

ws.on('emotion_shift', (state) => {
  // state.sentiment, state.trust, state.alertLevel
  updateCharacterAnimation(state);
});

ws.send({ message: 'I need to pass through here.' });

unity-sdk — For Unity Developers

The Unity SDK wraps the core API with MonoBehaviour components. Drop NPCDialogueController onto any GameObject, assign an NPC profile, and you're running.

using VantageSDK;

public class MerchantBehavior : MonoBehaviour
{
    private NPCDialogueController dialogue;

    void Start()
    {
        dialogue = GetComponent<NPCDialogueController>();
        dialogue.OnResponse += HandleResponse;
    }

    public void GreetPlayer(string playerId)
    {
        dialogue.SendMessage("Welcome! Looking for something special?", playerId);
    }

    void HandleResponse(DialogueResponse response)
    {
        Debug.Log($"{response.Text} [{response.Emotion}]");
        animator.SetTrigger(response.Emotion);
    }
}

unreal-plugin — For Unreal Engine 5

The Unreal plugin is a C++ module with Blueprint-exposed nodes. It supports both REST and WebSocket connections, with async Latent Actions for non-blocking inference calls.

void AMyNPC::OnPlayerInteract(FString PlayerId, FString Message)
{
    UVantageNPCComponent* Vantage = FindComponentByClass<UVantageNPCComponent>();

    FVantageChatRequest Request;
    Request.NpcId = NPCId;
    Request.PlayerId = PlayerId;
    Request.Message = Message;

    Vantage->Chat(Request, FOnVantageResponse::CreateUObject(
        this, &AMyNPC::HandleDialogueResponse
    ));
}

void AMyNPC::HandleDialogueResponse(const FVantageChatResponse& Response)
{
    SpeechBubble->SetText(FText::FromString(Response.Dialogue));
    PlayEmotionAnimation(Response.Emotion);
}

npc-dialogue-starter — Build Your Own

This is a standalone template for building NPC dialogue without our API. It works with any OpenAI-compatible endpoint (OpenAI, DeepSeek, Ollama, vLLM).

git clone https://github.com/maximilian32541-spec/npc-dialogue-starter
cd npc-dialogue-starter
npm install
cp .env.example .env  # Add your API key
node index.js

The architecture:

Player Input → Context Builder → LLM API → Response Parser → Game Engine
                    ↑                              |
                    └──── Memory / State ──────────┘

Four core modules:

Module	What it does
`DialogueManager`	Session history, message routing
`ContextBuilder`	NPC personality + world state injection
`MemoryStore`	Long-term memory with relevance scoring
`EmotionSystem`	Emotion-aware prompt modification

game-ai-utils — Debugging Tools

Three CLI tools for testing NPC behavior during development:

npc-bench — Benchmark response quality and latency:

node npc-bench.js --npc merchant --iterations 10 --concurrent 3

dialogue-replay — Replay saved conversations:

node dialogue-replay.js --file conversations/sample-merchant.json

prompt-lab — Interactive prompt testing:

node prompt-lab.js --npc=guard

Why Open Source?

Game AI is moving fast. Studios shouldn't have to rebuild basic infrastructure from scratch. By open-sourcing our tooling, we hope to:

Lower the barrier — Anyone can prototype NPC dialogue in an afternoon
Get feedback — Real game devs will find bugs and edge cases we miss
Build community — The best ideas come from people actually shipping games

Everything is MIT licensed. Use it in commercial projects, fork it, rip it apart.

What's Next

Voice synthesis integration (TTS + emotion mapping)
Multilingual NPC support (currently testing JP/KR/ZH)
Pre-built NPC personality templates

Check out the repos, open issues, and let us know what you're building.

Vantage Digital Labs builds AI tooling for game teams. vantage-digital.online · GitHub

How We Built Dynamic NPC Dialogue with LLMs — Lessons from Early Access

Murni Marcus — Mon, 25 May 2026 04:15:22 +0000

How We Built Dynamic NPC Dialogue with LLMs

We're a small team at Vantage Digital Labs building AI tooling for game developers. Our first product is an NPC dialogue engine powered by LLMs — and we've been running it in early access for a few months now. Here's what we've learned.

The Problem

Traditional NPC dialogue is written by hand. Every line, every branch, every response to every possible player input. For a small studio making an RPG with 50 NPCs, that's thousands of lines of dialogue — and it's all static.

What if NPCs could respond dynamically? What if a merchant could actually react to what the player says, instead of cycling through 3 pre-written lines?

Our Architecture

We went with a simple but effective pipeline:

Player Input → Context Builder → LLM API → Response Parser → Game Engine
                    ↑                              |
                    └──── Memory / State ──────────┘

Context Builder — Injects the NPC's personality, location, knowledge, and recent conversation history into a system prompt.

LLM API — We started with GPT-4o-mini, then tested DeepSeek and Qwen. For cost-sensitive indie games, smaller models work surprisingly well if the prompt is good.

Response Parser — Extracts the dialogue text plus metadata like emotion tags ([emotion:happy]) and action tags ([action:wave]).

Memory — A simple relevance-scored store that lets NPCs "remember" past interactions.

What Actually Matters

After running this for a few months, here's what we found:

1. System Prompt Engineering > Model Size

A well-crafted system prompt with a 7B model beats a generic prompt with GPT-4. We spend more time on personality definitions and context injection than on model selection.

You are Goron, a friendly dwarven merchant who loves haggling.
Location: Marketplace
You know about: prices, rare items, local rumors
Respond in character. Keep replies under 3 sentences.

Short, specific, constrained. That's it.

2. Response Parsing is Underrated

LLMs are chatty. Games need structured output. We use simple tag extraction:

const emotionMatch = raw.match(/\[emotion:(\w+)\]/i);
const actionMatch = raw.match(/\[action:([^\]]+)\]/i);
const text = raw.replace(/\[(emotion|action):[^\]]*\]/gi, '').trim();

This gives us clean dialogue text plus metadata for animation triggers.

3. Latency Matters More Than Quality

Players won't wait 3 seconds for an NPC to respond. We target <500ms total latency. This means:

Streaming responses (display text as it generates)
Smaller models for non-critical NPCs
Aggressive caching of common responses

4. Conversation History Windowing

Sending the full conversation history is expensive and slow. We window to the last 10 exchanges, with a separate memory system for important facts.

if (history.length > 20) history.splice(0, 2);

Simple, effective, cheap.

Cost Reality Check

For a game with 1000 daily active players, each talking to 5 NPCs per session:

GPT-4o-mini: ~$2-5/day
DeepSeek V3: ~$0.50-1/day
Self-hosted 7B: ~$0 (on existing game server)

For indie games, the economics work. It's not free, but it's cheaper than hiring a dialogue writer for every language.

Open Questions We're Still Working On

Consistency — How do you keep an NPC's personality stable across thousands of conversations?
Multilingual — Supporting 5+ languages without maintaining 5x the prompts
Voice — Combining LLM dialogue with real-time TTS (we're experimenting with this)

Try It

We have a live demo on our website where you can talk to NPCs powered by our engine. It's running a real inference backend, not canned responses.

If you're building a game and want to experiment with AI NPCs, we're in early access and happy to chat.

Vantage Digital Labs builds AI tooling for game teams. vantage-digital.online