devLap

DeepSeek V4 Pro Is Out. Here's How to Wire It Into Spring Boot With Spring AI

java dev.to

This morning my team's chat exploded the way it only does when a frontier model drops. The trigger was DeepSeek V4 Pro 0813, the GA release of DeepSeek V4 Pro, which hit Hacker News and climbed past 960 points with more than 400 comments in a few hours (the thread). Alibaba's Qwen team picked the same day to ship Qwen3.8-2.4T, a 2.4-trillion-parameter model. Two frontier-scale open-weight releases in one morning, and every feed I follow was reposting the same benchmark table.

My first question was not "how smart is it?" I have been building production AI systems with Spring Boot and Spring AI for over a year, so the question that actually matters for my stack is cheaper to answer: can I use this model from the code I already have, without adding a second SDK, a second auth path, or a second way to stream tokens? This week I wired DeepSeek V4 Pro into a Spring Boot app through Spring AI, and the answer turned out to be one dependency and four lines of config. Here is the setup, what I verified, and what I would check before pointing real traffic at it.

What actually shipped today

The 0813 suffix is a version stamp, and the date is literal: this is the GA release, and it landed today. The concrete details, from OpenRouter's model page and DeepSeek's announcement, relayed by a developer who tracks these releases:

  • A 1M-token context window. 1,048,576 tokens, matching the rest of the V4 family. That is roughly the full source of a mid-size service plus its docs plus a long conversation, all in one prompt.
  • A steep price cut. On OpenRouter, V4 Pro 0813 is $0.435 per million input tokens and $0.87 per million output tokens. The previous V4 Pro listing charged $1.168 and $2.336 per million, so this release is about 63% cheaper than its direct predecessor.
  • Big vendor-reported benchmark jumps. DeepSeek reports moving from 72.1% to 87.9% on Terminal-Bench 2.1, 52.7% to 83.3% on CyberGym, and 12.8% to 62.7% on DeepSWE. Those are the lab's own numbers, so treat them as directional, not gospel.
  • The family split. V4 Pro is the heavy lifter (1.6T total parameters, 49B active, per OpenRouter). V4 Flash is the cheap workhorse (284B total, 13B active) at around $0.08 per million input tokens. Both speak the same wire protocol, which matters for the build below.

Full disclosure: I have not moved any production traffic to this model, and everything I report from DeepSeek is vendor-reported. What I did do this week is point a real Spring Boot app at the model through the OpenRouter API and run it, including tool calls and streaming. That part I can stand behind.

Why Java teams should pay attention

The reason this is a config change and not a rewrite is that DeepSeek, like most labs now, exposes an OpenAI-compatible API, and OpenRouter does the same (their docs state it plainly). Spring AI's OpenAI starter does not care whether the server behind the endpoint is OpenAI, OpenRouter, DeepSeek, or a box of GPUs in your office. It speaks the OpenAI chat-completions shape, and anything that speaks that shape works.

The Hacker News thread is worth reading before you get excited, because the community has already started doing real agentic testing, and the results are more mixed than the benchmark table suggests:

  • One commenter ran a real deployment task. They gave the same job to DeepSeek V4 Pro and gpt-5.6-terra-high: generate a docker-compose stack behind Caddy with wildcard certificates, respecting port ranges already in use, with Postgres built in. "This one had few issues. terra: none" (comment). Their conclusion: benchmark results and observed agent behavior diverge once the task gets complicated.
  • Another ran it hard all day. A commenter let the model spin on a traffic simulator and distributed physics engine and reported "some pretty significant gains without introducing any new problems," helped by cache hits on repeated prompts (comment).
  • Some are staying on Flash. One commenter said the recent Flash update was such a capability jump for the price that they are "probably staying on Flash and not moving on to Pro" (comment).

That is a healthy sign for a model launch: people arguing about their actual workloads instead of quoting the press release. Now let me show you the integration, because that part is genuinely small.

The build: DeepSeek V4 Pro from Spring Boot

This assumes a normal Spring Boot 3.x project. I used the OpenRouter path because the model ID is verifiable there (deepseek/deepseek-v4-pro-0813) and you can sign up without a DeepSeek account. DeepSeek's own API, documented at api-docs.deepseek.com, follows the same OpenAI-compatible shape, so swapping the base URL is enough if you prefer first-party.

Step 1: add one dependency

Spring AI ships an OpenAI-compatible starter that covers chat, embeddings, streaming, and tool calling. Add it to your pom.xml, pinning the Spring AI BOM version your project already uses:

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-openai</artifactId>
</dependency>
Enter fullscreen mode Exit fullscreen mode

If you already use Spring AI for anything, you already have this dependency, which is the whole point.

Step 2: point Spring AI at the model

Four lines in application.properties:

spring.ai.openai.base-url=https://openrouter.ai/api/v1
spring.ai.openai.api-key=${OPENROUTER_API_KEY}
spring.ai.openai.chat.options.model=deepseek/deepseek-v4-pro-0813
spring.ai.openai.chat.options.temperature=0.3
Enter fullscreen mode Exit fullscreen mode

That is the entire integration. The base URL swaps the endpoint, the key authenticates, and the model option picks the exact release. Everything else, the retries, the request building, the response parsing, comes from Spring AI.

Step 3: a minimal chat endpoint

Spring AI 1.x gives you a typed ChatClient instead of a loose SDK wrapper. Autowire the builder and you are done:

@RestController
public class AssistantController {

    private final ChatClient chatClient;

    public AssistantController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    @GetMapping("/ask")
    public String ask(@RequestParam String question) {
        return chatClient.prompt()
                .user(question)
                .call()
                .content();
    }
}
Enter fullscreen mode Exit fullscreen mode

GET /ask?question=why+is+the+sky+blue now returns a DeepSeek V4 Pro answer. That is the whole loop: one controller, one client, one config block.

Step 4: stream the response

Interactive agents feel slow when they buffer a full answer, so the streaming variant matters. Spring AI returns a Flux<String> that works directly with Server-Sent Events:

@GetMapping(value = "/ask/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> askStream(@RequestParam String question) {
    return chatClient.prompt()
            .user(question)
            .stream()
            .content();
}
Enter fullscreen mode Exit fullscreen mode

Test it with curl:

curl -N "http://localhost:8080/ask/stream?question=explain+vector+databases+in+one+paragraph"
Enter fullscreen mode Exit fullscreen mode

Tokens arrive as the model generates them, which is the behavior you want for anything user-facing.

Step 5: give the model tools

Tool calling is where agents earn their keep, and this is where the OpenAI-compatible protocol pays off twice. Define a plain Spring bean with @Tool methods:

@Component
public class WeatherTools {

    @Tool(name = "get_temperature", description = "Returns the current temperature in Celsius for a city")
    public String getTemperature(String city) {
        return "31"; // pretend this calls a weather API
    }
}
Enter fullscreen mode Exit fullscreen mode

Then register the tools on the prompt:

String answer = chatClient.prompt()
        .user("What is the temperature in Dhaka?")
        .tools(new WeatherTools())
        .call()
        .content();
Enter fullscreen mode Exit fullscreen mode

Spring AI serializes the tool schema, sends it in OpenAI format, and DeepSeek's function-calling responses parse back through the same path. No vendor-specific tool protocol to learn.

Step 6: structured output

If you want JSON back instead of prose, .entity() maps the response onto a record:

public record ModelSummary(String name, int contextTokens, double inputPricePerMToken) {}

ModelSummary summary = chatClient.prompt()
        .user("Summarize the pricing of DeepSeek V4 Pro 0813.")
        .call()
        .entity(ModelSummary.class);
Enter fullscreen mode Exit fullscreen mode

That covers chat, streaming, tools, and structured output. Roughly 40 lines of Java, none of it DeepSeek-specific.

What the 1M context window changes

The context size is the feature that changes how you build, more than the benchmark deltas:

  • Whole-repo prompts become practical. You can stuff a service's source and docs into one call instead of maintaining a RAG pipeline. That removes infrastructure, but it moves the cost and latency problem into the prompt, so it is a trade, not a free win.
  • Prompt caching becomes your best friend. Long, mostly-static prompts get cache hits on repeat calls, which is why the HN commenter's all-day agent run stayed cheap. Structure your prompts so the stable parts (system prompt, repo dump) come first and the changing part (the user request) comes last; caching works best that way on most providers.
  • First-token latency grows with context. A 1M-token prompt takes time to process before the first token arrives. For an interactive agent, a 200k-token prompt that starts answering in 2 seconds often beats a 1M-token prompt that starts answering in 20. Size the context to the task, not to the limit.

The checklist I would run before production

If you are tempted to wire this into a real service, here is what I would verify first, and the order matters:

  • Cap the spend before you enable it. $0.435 per million input tokens is cheap per token and expensive per careless loop. Set a token or dollar cap per request and per key before the first user hits it.
  • Evaluate on your workload, not the table. The HN deployment test showed a real task where this model slipped and a competitor did not. Replay your own tricky prompts, especially the ones with many steps, and compare against whatever you run today.
  • Keep a fallback route. Configure the model ID and base URL as properties, not constants, and keep a second provider or the Flash variant one config flip away. Model launches are weekly now; your routing layer should be older than your model choice.
  • Test tool calling with your real functions. Function calling works, but reliability varies by model and by schema complexity. Run your actual tool set, not a toy, and watch for loops where the model calls the same tool repeatedly.
  • Watch the cache-hit ratio. If your prompts change shape constantly, you get no caching benefit and the long-context pricing math stops working in your favor. Log prompt size and cache hits before you commit.

What I would do differently

The durable lesson from this launch has nothing to do with DeepSeek. Every few weeks there is a new model that everyone rushes to try, and the teams that adopt them fastest are not the ones that learned the model. They are the ones whose code treats the model as configuration. If your Spring Boot app already speaks the OpenAI-compatible protocol, adopting a model is changing a base URL and a model name, not merging a vendor SDK. The model is config, not code, and this release is the cleanest demonstration of that in a while.

I have been on both sides of that fence: the first time I integrated a frontier model I built a custom client, a custom retry layer, and a custom parser. The next time I changed a properties file. The second approach took ten minutes and survived four model generations without a code change.

Have you tried DeepSeek V4 Pro or V4 Flash yet? What does your real workload show, versus what the benchmark table promised? I read every response.

I write about Java, Spring Boot, and AI every week. Subscribe, it's free.

Bookmark this one. Next time a model launches, your first question should not be "how smart is it?" It should be "how many lines of code does adopting it cost?" For this one, the answer is four.

Source: dev.to

arrow_back Back to Tutorials