chore: import upstream snapshot with attribution

apps/sim/tools/qdrant/fetch_points.ts

@@ -0,0 +1,119 @@
+import type { QdrantFetchParams, QdrantResponse } from '@/tools/qdrant/types'
+import { POINT_OUTPUT_PROPERTIES, QDRANT_RESPONSE_OUTPUT_PROPERTIES } from '@/tools/qdrant/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const fetchPointsTool: ToolConfig<QdrantFetchParams, QdrantResponse> = {
+  id: 'qdrant_fetch_points',
+  name: 'Qdrant Fetch Points',
+  description: 'Fetch points by ID from a Qdrant collection',
+  version: '1.0',
+
+  params: {
+    url: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Qdrant instance URL (e.g., https://your-cluster.qdrant.io)',
+    },
+    apiKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Qdrant API key for authentication',
+    },
+    collection: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Collection name to fetch from (e.g., "my_collection")',
+    },
+    ids: {
+      type: 'array',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Array of point IDs to fetch (e.g., ["id1", "id2"] or [1, 2])',
+    },
+    fetch_return_data: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Data to return from fetch',
+    },
+    with_payload: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Include payload in response',
+    },
+    with_vector: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Include vector in response',
+    },
+  },
+
+  request: {
+    method: 'POST',
+    url: (params) => `${params.url.replace(/\/$/, '')}/collections/${params.collection}/points`,
+    headers: (params) => ({
+      'Content-Type': 'application/json',
+      ...(params.apiKey ? { 'api-key': params.apiKey } : {}),
+    }),
+    body: (params) => {
+      // Calculate with_payload and with_vector from fetch_return_data if provided
+      let withPayload = params.with_payload ?? false
+      let withVector = params.with_vector ?? false
+
+      if (params.fetch_return_data) {
+        switch (params.fetch_return_data) {
+          case 'payload_only':
+            withPayload = true
+            withVector = false
+            break
+          case 'vector_only':
+            withPayload = false
+            withVector = true
+            break
+          case 'both':
+            withPayload = true
+            withVector = true
+            break
+          case 'none':
+            withPayload = false
+            withVector = false
+            break
+        }
+      }
+
+      return {
+        ids: params.ids,
+        with_payload: withPayload,
+        with_vector: withVector,
+      }
+    },
+  },
+
+  transformResponse: async (response) => {
+    const data = await response.json()
+    return {
+      success: true,
+      output: {
+        data: data.result,
+        status: data.status,
+      },
+    }
+  },
+
+  outputs: {
+    data: {
+      type: 'array',
+      description: 'Fetched points with ID, payload, and optional vector data',
+      items: {
+        type: 'object',
+        properties: POINT_OUTPUT_PROPERTIES,
+      },
+    },
+    status: QDRANT_RESPONSE_OUTPUT_PROPERTIES.status,
+  },
+}

apps/sim/tools/qdrant/index.ts

@@ -0,0 +1,7 @@
+import { fetchPointsTool } from '@/tools/qdrant/fetch_points'
+import { searchVectorTool } from '@/tools/qdrant/search_vector'
+import { upsertPointsTool } from '@/tools/qdrant/upsert_points'
+
+export const qdrantUpsertTool = upsertPointsTool
+export const qdrantSearchTool = searchVectorTool
+export const qdrantFetchTool = fetchPointsTool

apps/sim/tools/qdrant/search_vector.ts

@@ -0,0 +1,138 @@
+import type { QdrantResponse, QdrantSearchParams } from '@/tools/qdrant/types'
+import {
+  QDRANT_RESPONSE_OUTPUT_PROPERTIES,
+  SCORED_POINT_OUTPUT_PROPERTIES,
+} from '@/tools/qdrant/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const searchVectorTool: ToolConfig<QdrantSearchParams, QdrantResponse> = {
+  id: 'qdrant_search_vector',
+  name: 'Qdrant Search Vector',
+  description: 'Search for similar vectors in a Qdrant collection',
+  version: '1.0',
+
+  params: {
+    url: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Qdrant instance URL (e.g., https://your-cluster.qdrant.io)',
+    },
+    apiKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Qdrant API key for authentication',
+    },
+    collection: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Collection name to search (e.g., "my_collection")',
+    },
+    vector: {
+      type: 'array',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Query vector for similarity search (e.g., [0.1, 0.2, 0.3, ...])',
+    },
+    limit: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Maximum number of results to return (e.g., 10)',
+    },
+    filter: {
+      type: 'object',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'Qdrant filter object (e.g., {"must": [{"key": "field", "match": {"value": "val"}}]})',
+    },
+    search_return_data: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Data to return from search',
+    },
+    with_payload: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Include payload in response',
+    },
+    with_vector: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Include vector in response',
+    },
+  },
+
+  request: {
+    method: 'POST',
+    url: (params) =>
+      `${params.url.replace(/\/$/, '')}/collections/${encodeURIComponent(params.collection)}/points/query`,
+    headers: (params) => ({
+      'Content-Type': 'application/json',
+      ...(params.apiKey ? { 'api-key': params.apiKey } : {}),
+    }),
+    body: (params) => {
+      // Calculate with_payload and with_vector from search_return_data if provided
+      let withPayload = params.with_payload ?? false
+      let withVector = params.with_vector ?? false
+
+      if (params.search_return_data) {
+        switch (params.search_return_data) {
+          case 'payload_only':
+            withPayload = true
+            withVector = false
+            break
+          case 'vector_only':
+            withPayload = false
+            withVector = true
+            break
+          case 'both':
+            withPayload = true
+            withVector = true
+            break
+          case 'none':
+            withPayload = false
+            withVector = false
+            break
+        }
+      }
+
+      return {
+        query: params.vector,
+        limit: params.limit ? Number(params.limit) : 10,
+        filter: params.filter,
+        with_payload: withPayload,
+        with_vector: withVector,
+      }
+    },
+  },
+
+  transformResponse: async (response) => {
+    const data = await response.json()
+    return {
+      success: true,
+      output: {
+        data: data.result,
+        status: data.status,
+      },
+    }
+  },
+
+  outputs: {
+    data: {
+      type: 'array',
+      description: 'Vector search results with ID, score, payload, and optional vector data',
+      items: {
+        type: 'object',
+        properties: SCORED_POINT_OUTPUT_PROPERTIES,
+      },
+    },
+    status: QDRANT_RESPONSE_OUTPUT_PROPERTIES.status,
+  },
+}

apps/sim/tools/qdrant/types.ts

@@ -0,0 +1,141 @@
+import type { OutputProperty, ToolResponse } from '@/tools/types'
+
+/**
+ * Shared output property definitions for Qdrant API responses.
+ * Based on official Qdrant REST API documentation.
+ * @see https://api.qdrant.tech/
+ */
+
+/**
+ * Output definition for point objects returned by fetch/get operations
+ */
+export const POINT_OUTPUT_PROPERTIES = {
+  id: { type: 'string', description: 'Point ID (integer or UUID string)' },
+  payload: { type: 'json', description: 'Point payload data (key-value pairs)', optional: true },
+  vector: {
+    type: 'json',
+    description: 'Point vector(s) - single array or named vectors object',
+    optional: true,
+  },
+  shard_key: { type: 'string', description: 'Shard key for routing', optional: true },
+  order_value: {
+    type: 'number',
+    description: 'Order value for sorting',
+    optional: true,
+  },
+} as const satisfies Record<string, OutputProperty>
+
+/**
+ * Complete point object output definition
+ */
+export const POINT_OUTPUT: OutputProperty = {
+  type: 'object',
+  description: 'Point object with ID, payload, and optional vector',
+  properties: POINT_OUTPUT_PROPERTIES,
+}
+
+/**
+ * Output definition for scored point objects returned by search/query operations
+ */
+export const SCORED_POINT_OUTPUT_PROPERTIES = {
+  id: { type: 'string', description: 'Point ID (integer or UUID string)' },
+  version: { type: 'number', description: 'Point version number' },
+  score: { type: 'number', description: 'Similarity score' },
+  payload: { type: 'json', description: 'Point payload data (key-value pairs)', optional: true },
+  vector: {
+    type: 'json',
+    description: 'Point vector(s) - single array or named vectors object',
+    optional: true,
+  },
+  shard_key: { type: 'string', description: 'Shard key for routing', optional: true },
+  order_value: {
+    type: 'number',
+    description: 'Order value for sorting',
+    optional: true,
+  },
+} as const satisfies Record<string, OutputProperty>
+
+/**
+ * Complete scored point object output definition
+ */
+export const SCORED_POINT_OUTPUT: OutputProperty = {
+  type: 'object',
+  description: 'Scored point with ID, version, score, payload, and optional vector',
+  properties: SCORED_POINT_OUTPUT_PROPERTIES,
+}
+
+/**
+ * Output definition for upsert operation result
+ */
+export const UPSERT_RESULT_OUTPUT_PROPERTIES = {
+  operation_id: { type: 'number', description: 'Operation ID for async tracking', optional: true },
+  status: {
+    type: 'string',
+    description: 'Operation status (acknowledged, completed)',
+    optional: true,
+  },
+} as const satisfies Record<string, OutputProperty>
+
+/**
+ * Complete upsert result output definition
+ */
+export const UPSERT_RESULT_OUTPUT: OutputProperty = {
+  type: 'object',
+  description: 'Upsert operation result with operation ID and status',
+  properties: UPSERT_RESULT_OUTPUT_PROPERTIES,
+}
+
+/**
+ * Common response properties for all Qdrant operations
+ */
+export const QDRANT_RESPONSE_OUTPUT_PROPERTIES = {
+  status: { type: 'string', description: 'Operation status (ok, error)' },
+  time: { type: 'number', description: 'Time spent processing request in seconds', optional: true },
+} as const satisfies Record<string, OutputProperty>
+
+interface QdrantBaseParams {
+  url: string
+  apiKey?: string
+  collection: string
+}
+
+interface QdrantVector {
+  id: string
+  vector: number[]
+  payload?: Record<string, any>
+}
+
+export interface QdrantUpsertParams extends QdrantBaseParams {
+  points: QdrantVector[]
+}
+
+export interface QdrantSearchParams extends QdrantBaseParams {
+  vector: number[]
+  limit?: number
+  filter?: Record<string, any>
+  search_return_data?: string
+  with_payload?: boolean
+  with_vector?: boolean
+}
+
+export interface QdrantFetchParams extends QdrantBaseParams {
+  ids: string[]
+  fetch_return_data?: string
+  with_payload?: boolean
+  with_vector?: boolean
+}
+
+export interface QdrantResponse extends ToolResponse {
+  output: {
+    result?: any
+    status?: string
+    matches?: Array<{
+      id: string
+      score: number
+      payload?: Record<string, any>
+      vector?: number[]
+    }>
+    upsertedCount?: number
+    data?: any
+  }
+}

apps/sim/tools/qdrant/upsert_points.ts

@@ -0,0 +1,70 @@
+import type { QdrantResponse, QdrantUpsertParams } from '@/tools/qdrant/types'
+import {
+  QDRANT_RESPONSE_OUTPUT_PROPERTIES,
+  UPSERT_RESULT_OUTPUT_PROPERTIES,
+} from '@/tools/qdrant/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const upsertPointsTool: ToolConfig<QdrantUpsertParams, QdrantResponse> = {
+  id: 'qdrant_upsert_points',
+  name: 'Qdrant Upsert Points',
+  description: 'Insert or update points in a Qdrant collection',
+  version: '1.0',
+
+  params: {
+    url: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Qdrant instance URL (e.g., https://your-cluster.qdrant.io)',
+    },
+    apiKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Qdrant API key for authentication',
+    },
+    collection: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Collection name for upsert (e.g., "my_collection")',
+    },
+    points: {
+      type: 'array',
+      required: true,
+      visibility: 'user-only',
+      description: 'Array of points to upsert',
+    },
+  },
+
+  request: {
+    method: 'PUT',
+    url: (params) => `${params.url.replace(/\/$/, '')}/collections/${params.collection}/points`,
+    headers: (params) => ({
+      'Content-Type': 'application/json',
+      ...(params.apiKey ? { 'api-key': params.apiKey } : {}),
+    }),
+    body: (params) => ({ points: params.points }),
+  },
+
+  transformResponse: async (response) => {
+    const data = await response.json()
+    return {
+      success: response.ok && data.status === 'ok',
+      output: {
+        status: data.status,
+        data: data.result,
+      },
+    }
+  },
+
+  outputs: {
+    status: QDRANT_RESPONSE_OUTPUT_PROPERTIES.status,
+    data: {
+      type: 'object',
+      description: 'Result data from the upsert operation',
+      properties: UPSERT_RESULT_OUTPUT_PROPERTIES,
+    },
+  },
+}