Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

Help me set up a new conjure java project. I want to go from 0 to having a functional…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-30b-a3b’s answer.
  1. User

    Help me set up a new conjure java project. I want to go from 0 to having a functional dummy api. Here is conjure docs: https://github.com/palantir/conjure. Set the project up with gradle.

    Walk me step by step. On each step, explain why it's needed. Keep in mind to add only the absolutely necessary configurations.

  2. DeepSeek Assistant

    Let's set up a minimal Conjure Java project with Gradle. I'll break this down into essential steps with explanations:

    Step 1: Create Project Structure

    mkdir my-conjure-project
    cd my-conjure-project
    mkdir -p api/src/main/conjure  # Conjure API definitions
    mkdir -p server/src/main/java  # Server implementation
    

    Why: Conjure requires a specific directory structure for API definitions. We're separating API definitions (api) from implementation (server).

    Step 2: Initialize Gradle

    Create settings.gradle:

    rootProject.name = 'my-conjure-project'
    include 'api', 'server'
    

    Why: Defines a multi-project build with separate modules for API definition and server implementation.

    Step 3: Root Build Configuration (build.gradle)

    // Top-level build configuration
    allprojects {
        repositories {
            mavenCentral()
        }
    }
    
    buildscript {
        repositories { mavenCentral() }
        dependencies {
            classpath 'com.palantir.gradle.conjure:gradle-conjure:5.0.0' // Check latest version
        }
    }
    

    Why:

    • Centralizes Maven repository configuration
    • Adds Conjure Gradle plugin dependency

    Step 4: API Module Configuration (api/build.gradle)

    apply plugin: 'com.palantir.conjure'
    
    dependencies {
        implementation "com.palantir.conjure.java:conjure-lib:5.0.0"
    }
    
    conjure {
        java {
            // Generate Undertow service interfaces
            undertowServicePrefixes = true
        }
    }
    

    Why:

    • Applies Conjure plugin to generate Java code from API definitions
    • conjure-lib dependency provides runtime annotations
    • undertowServicePrefixes enables Undertow-compatible interfaces

    Step 5: Define API Contract (api/src/main/conjure/api.yml)

    types:
      definitions:
        default-package: com.example.api
        objects:
          Greeting:
            fields:
              message: string
    
    services:
      HelloService:
        name: Hello Service
        package: com.example.api
    
        endpoints:
          getGreeting:
            http: GET /greeting
            returns: Greeting
    

    Why:

    • Defines a simple API with one endpoint
    • Greeting object demonstrates type generation
    • Package structure determines Java package names

    Step 6: Server Module Configuration (server/build.gradle)

    apply plugin: 'application'
    mainClassName = 'com.example.server.ServerMain'
    
    dependencies {
        implementation project(':api')  // Generated Conjure code
        implementation 'com.palantir.conjure.java.runtime:conjure-java-undertow-runtime:5.0.0'
        implementation 'io.undertow:undertow-core:2.2.18.Final'
    }
    

    Why:

    • application plugin enables running the server
    • Depends on generated API code
    • Undertow dependencies provide HTTP server implementation

    Step 7: Implement Service (server/src/main/java/com/example/server/HelloServiceImpl.java)

    package com.example.server;
    
    import com.example.api.Greeting;
    import com.example.api.HelloService;
    
    public final class HelloServiceImpl implements HelloService {
        @Override
        public Greeting getGreeting() {
            return Greeting.builder().message("Hello, Conjure!").build();
        }
    }
    

    Why:

    • Implements the Conjure-generated service interface
    • Provides business logic for the API endpoint

    Step 8: Create Server Main Class (server/src/main/java/com/example/server/ServerMain.java)

    package com.example.server;
    
    import com.example.api.HelloServiceEndpoints;
    import com.palantir.conjure.java.undertow.runtime.ConjureHandler;
    import io.undertow.Undertow;
    
    public class ServerMain {
        public static void main(String[] args) {
            HelloService service = new HelloServiceImpl();
            
            ConjureHandler handler = ConjureHandler.builder()
                .addAllEndpoints(HelloServiceEndpoints.of(service))
                .build();
    
            Undertow server = Undertow.builder()
                .addHttpListener(8080, "0.0.0.0")
                .setHandler(handler)
                .build();
            
            server.start();
            System.out.println("Server started on port 8080");
        }
    }
    

    Why:

    • Configures Undertow HTTP server
    • Binds service implementation to endpoints
    • Starts server on port 8080

    Step 9: Build and Run

    # Generate API code and build all modules
    ./gradlew build
    
    # Run the server
    ./gradlew :server:run
    

    Step 10: Test the API

    curl http://localhost:8080/greeting
    

    Expected Response:

    {"message":"Hello, Conjure!"}
    

    Key Files Summary

    ├── build.gradle
    ├── settings.gradle
    ├── api
    │   ├── build.gradle
    │   └── src/main/conjure/api.yml
    └── server
        ├── build.gradle
        └── src/main/java
            └── com/example/server
                ├── HelloServiceImpl.java
                └── ServerMain.java
    

    Why This Setup Works

    1. Separation of Concerns: API definition separate from implementation
    2. Code Generation: Conjure auto-generates:
      • POJOs (Greeting.java)
      • Service interfaces (HelloService.java)
      • Undertow bindings (HelloServiceEndpoints.java)
    3. Minimal Dependencies: Only essential Conjure and Undertow libraries
    4. Type Safety: All API contracts are compile-time checked

    This setup gives you a fully functional Conjure API with a single endpoint, ready for extension.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.