API Reference

Authorization: Bearer lx_a1b2c3d4e5f6...

curl -X POST https://dawk-ps2.vercel.app/api/v1/query \
  -H "Authorization: Bearer lx_a1b2c3d4..." \
  -H "Content-Type: application/json" \
  -d '{
    "plugin": "structural-eng-v1",
    "query": "What is the minimum cover for a beam in severe exposure?"
  }'

curl -X POST https://dawk-ps2.vercel.app/api/v1/query \
  -H "Authorization: Bearer lx_a1b2c3d4..." \
  -H "Content-Type: application/json" \
  -d '{
    "plugin": "structural-eng-v1",
    "query": "What about for a column instead?",
    "context": [
      { "role": "user", "content": "What is the minimum cover for a beam in severe exposure?" },
      { "role": "assistant", "content": "According to IS 456 Table 16, the minimum nominal cover for a beam in severe exposure is 45mm." }
    ]
  }'

curl -X POST https://dawk-ps2.vercel.app/api/v1/query \
  -H "Authorization: Bearer lx_a1b2c3d4..." \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{
    "plugin": "structural-eng-v1",
    "query": "What is the minimum cover for a beam in severe exposure?",
    "stream": true
  }'

{
  "answer": "According to IS 456 Table 16, the minimum nominal cover for a beam in severe exposure is 45mm. [Source 1]",
  "citations": [
    {
      "id": "chunk_abc123",
      "document": "IS-456-2000.pdf",
      "page": 34,
      "section": "Table 16 — Nominal Cover",
      "excerpt": "For severe exposure conditions, beams require 45mm minimum cover..."
    }
  ],
  "decisionPath": [
    { "step": 1, "node": "q1", "label": "Member Type", "value": "beam" },
    { "step": 2, "node": "q2", "label": "Exposure Class", "value": "severe" },
    { "step": 3, "node": "a1", "label": "Cover Recommendation", "result": "45mm nominal cover" }
  ],
  "confidence": "high",
  "pluginVersion": "1"
}

data: {"type":"status","status":"retrieving","message":"Found 5 relevant sources","sourceCount":5}

data: {"type":"delta","text":"According to "}

data: {"type":"delta","text":"IS 456 Table 16..."}

data: {"type":"done","answer":"...full answer...","citations":[...],"decisionPath":[...],"confidence":"high","pluginVersion":"1"}

curl -X POST https://dawk-ps2.vercel.app/api/v1/collaborate \
  -H "Authorization: Bearer lx_a1b2c3d4..." \
  -H "Content-Type: application/json" \
  -d '{
    "experts": ["structural-eng-v1", "geotech-v1"],
    "query": "What foundation type is best for a 5-story building on expansive clay soil?",
    "mode": "debate",
    "maxRounds": 2
  }'

{
  "rounds": [
    {
      "roundNumber": 1,
      "responses": [
        {
          "pluginSlug": "structural-eng-v1",
          "pluginName": "Structural Engineering Expert",
          "domain": "Structural Engineering",
          "answer": "For a 5-story building on expansive clay...",
          "citations": [...],
          "confidence": "high",
          "revised": false
        },
        {
          "pluginSlug": "geotech-v1",
          "pluginName": "Geotechnical Expert",
          "domain": "Geotechnical Engineering",
          "answer": "Expansive clay soils require...",
          "citations": [...],
          "confidence": "high",
          "revised": false
        }
      ]
    }
  ],
  "consensus": {
    "answer": "Both experts agree that a mat/raft foundation is recommended...",
    "confidence": "high",
    "agreementLevel": 0.85,
    "citations": [...],
    "conflicts": [
      {
        "topic": "Pile depth requirements",
        "positions": [
          { "expert": "structural-eng-v1", "stance": "Minimum 15m driven piles" },
          { "expert": "geotech-v1", "stance": "12m bored piles sufficient" }
        ],
        "resolved": true,
        "resolution": "Bored piles at 12-15m depth recommended pending soil investigation"
      }
    ],
    "expertContributions": [
      { "expert": "structural-eng-v1", "domain": "Structural Engineering", "keyPoints": ["Load analysis", "Foundation sizing"] },
      { "expert": "geotech-v1", "domain": "Geotechnical Engineering", "keyPoints": ["Soil bearing capacity", "Settlement analysis"] }
    ]
  },
  "latencyMs": 12450
}

data: {"type":"status","status":"resolving","message":"Resolving expert plugins..."}

data: {"type":"experts_resolved","experts":[{"slug":"structural-eng-v1","name":"Structural Engineering Expert","domain":"Structural Engineering","sourceCount":42,"hasDecisionTree":true},{"slug":"geotech-v1",...}]}

data: {"type":"round_start","round":1,"totalRounds":2}

data: {"type":"expert_thinking","expert":"structural-eng-v1","expertName":"Structural Engineering Expert","domain":"Structural Engineering","message":"Analyzing with 42 sources..."}

data: {"type":"expert_response","round":1,"expert":"structural-eng-v1","expertName":"Structural Engineering Expert","domain":"Structural Engineering","answer":"...","citations":[...],"confidence":"high","revised":false}

data: {"type":"round_complete","round":1}

data: {"type":"done","rounds":[...],"consensus":{...},"latencyMs":12450}

npm install lexic-sdk

import { Lexic } from "lexic-sdk";

const lexic = new Lexic({
  apiKey: "lx_your_api_key",
  defaultPlugin: "structural-eng-v1",
});

const result = await lexic.query({
  query: "Minimum cover for a beam in severe exposure?",
});

console.log(result.answer);       // Cited expert answer
console.log(result.citations);    // Source references
console.log(result.confidence);   // "high" | "medium" | "low"
console.log(result.decisionPath); // Decision tree steps

const lexic = new Lexic({ apiKey: "lx_..." });

// Query the structural engineering expert
lexic.setActivePlugin("structural-eng-v1");
const structResult = await lexic.query({
  query: "Max allowable deflection for a cantilever?",
});

// Instantly switch to a different domain expert
lexic.setActivePlugin("electrical-code-v2");
const elecResult = await lexic.query({
  query: "Wire sizing for a 30A circuit?",
});

const result1 = await lexic.query({
  query: "What is the minimum cover for a beam in severe exposure?",
});

const result2 = await lexic.query({
  query: "What about for a column instead?",
  context: [
    { role: "user", content: "What is the minimum cover for a beam in severe exposure?" },
    { role: "assistant", content: result1.answer },
  ],
});

import { Lexic, LexicAPIError } from "lexic-sdk";

try {
  const result = await lexic.query({ query: "..." });
} catch (err) {
  if (err instanceof LexicAPIError) {
    console.error(err.message); // "Plugin not found or access denied"
    console.error(err.status);  // 404
  }
}

npm install lexic-sdk

import { LexicTool } from "lexic-sdk/langchain";

const tool = new LexicTool({
  apiKey: "lx_your_api_key",
  plugin: "structural-eng-v1",
  name: "structural_expert",
  description: "Consult a structural engineering expert",
  queryOptions: {
    citationMode: "inline",
    maxSources: 5,
    includeDecisionPath: true,
  },
});

// Add to any LangChain agent
const agent = createOpenAIToolsAgent({ llm, tools: [tool], prompt });

// Hot-swap to a different expert
tool.setPlugin("electrical-code-v2");

import { LexicCollaborationTool } from "lexic-sdk/langchain";

const collabTool = new LexicCollaborationTool({
  apiKey: "lx_your_api_key",
  experts: ["structural-eng-v1", "geotech-v1"],
  name: "expert_panel",
  description: "Consult multiple domain experts for adversarial analysis",
  mode: "debate",
  maxRounds: 2,
  onEvent: (event) => {
    if (event.type === "expert_thinking") {
      console.log(`${event.expertName}: ${event.message}`);
    }
  },
});

// Add to LangChain agent alongside single-expert tools
const agent = createOpenAIToolsAgent({
  llm,
  tools: [tool, collabTool],
  prompt,
});

// Dynamically change experts or mode
collabTool.setExperts(["structural-eng-v1", "fire-safety-v1"]);
collabTool.setMode("consensus");

import { LexicAutoGPT } from "lexic-sdk/autogpt";

const adapter = new LexicAutoGPT({
  apiKey: "lx_your_api_key",
  plugin: "structural-eng-v1",
  commandName: "consult_structural_expert",
  commandDescription: "Ask the structural expert",
  queryOptions: {
    citationMode: "inline",
    maxSources: 5,
    includeDecisionPath: true,
  },
});

// Register as an AutoGPT command
const command = adapter.asCommand();
// command.name, command.description, command.parameters, command.execute

// Or execute directly
const answer = await adapter.execute(
  "What is the minimum reinforcement ratio for a slab?"
);

import { LexicCollaborationAutoGPT } from "lexic-sdk/autogpt";

const collabAdapter = new LexicCollaborationAutoGPT({
  apiKey: "lx_your_api_key",
  experts: ["structural-eng-v1", "geotech-v1"],
  commandName: "consult_expert_panel",
  commandDescription: "Ask multiple domain experts to debate and reach consensus",
  mode: "debate",
  maxRounds: 2,
  onEvent: (event) => {
    if (event.type === "expert_thinking") {
      console.log(`${event.expertName}: ${event.message}`);
    }
  },
});

// Register as AutoGPT command
const command = collabAdapter.asCommand();

// Or execute directly
const answer = await collabAdapter.execute(
  "Best foundation for a 5-story building on clay?"
);

// Change experts or mode at runtime
collabAdapter.setExperts(["structural-eng-v1", "fire-safety-v1"]);
collabAdapter.setMode("consensus");

interface LexicConfig {
  apiKey: string;
  baseUrl?: string;
  defaultPlugin?: string;
  timeout?: number;
}

interface QueryRequestOptions {
  citationMode?: "inline" | "footnote" | "off";
  maxSources?: number;
  includeDecisionPath?: boolean;
}

interface QueryOptions {
  plugin?: string;
  query: string;
  context?: Array<{ role: "user" | "assistant"; content: string }>;
  options?: QueryRequestOptions;
}

interface QueryResult {
  answer: string;
  citations: Citation[];
  decisionPath: DecisionStep[];
  confidence: "high" | "medium" | "low";
  pluginVersion: string;
}

interface Citation {
  id: string;
  document: string;
  page?: number;
  section?: string;
  excerpt: string;
}

interface DecisionStep {
  step: number;
  node: string;
  label: string;
  value?: string;
  result?: string;
}

interface LexicError {
  error: string;
  status?: number;
}

type StreamEvent =
  | { type: "status"; status: string; message: string; sourceCount?: number }
  | { type: "delta"; text: string }
  | { type: "done"; answer: string; citations: Citation[];
      decisionPath: DecisionStep[];
      confidence: "high" | "medium" | "low";
      pluginVersion: string }
  | { type: "error"; error: string };

type CollaborationMode = "debate" | "consensus" | "review";

interface CollaborateOptions {
  experts: string[];
  query: string;
  mode?: CollaborationMode;
  maxRounds?: number;
}

interface ExpertResponse {
  pluginSlug: string;
  pluginName: string;
  domain: string;
  answer: string;
  citations: Citation[];
  confidence: "high" | "medium" | "low";
  revised: boolean;
  revisionNote?: string;
}

interface CollaborationRound {
  roundNumber: number;
  responses: ExpertResponse[];
}

interface ConflictEntry {
  topic: string;
  positions: Array<{ expert: string; stance: string }>;
  resolved: boolean;
  resolution?: string;
}

interface ConsensusResult {
  answer: string;
  confidence: "high" | "medium" | "low";
  agreementLevel: number;
  citations: Citation[];
  conflicts: ConflictEntry[];
  expertContributions: Array<{
    expert: string;
    domain: string;
    keyPoints: string[];
  }>;
}

interface CollaborationResult {
  rounds: CollaborationRound[];
  consensus: ConsensusResult;
  latencyMs: number;
}

type CollaborationStreamEvent =
  | { type: "status"; status: string; message: string }
  | { type: "experts_resolved"; experts: Array<{
      slug: string; name: string; domain: string;
      sourceCount: number; hasDecisionTree: boolean
    }> }
  | { type: "round_start"; round: number; totalRounds: number }
  | { type: "expert_thinking"; expert: string;
      expertName: string; domain: string; message: string }
  | { type: "expert_response"; round: number; expert: string;
      expertName: string; domain: string; answer: string;
      citations: Citation[];
      confidence: "high" | "medium" | "low"; revised: boolean }
  | { type: "round_complete"; round: number }
  | { type: "done"; rounds: CollaborationRound[];
      consensus: ConsensusResult; latencyMs: number }
  | { type: "error"; error: string };

{
  "error": "Human-readable error message"
}