valyu-js 1.0.0

package/README.md

@@ -0,0 +1,40 @@
+# Valyu SDK for Node.js
+
+Connect your AI applications to high-quality proprietary data with Valyu, an AI context engine built by AI Engineers for AI Engineers.
+
+## Why Valyu?
+
+- **Ready-to-use RAG Data**: All data is returned in Markdown format, optimized for AI consumption.
+- **Multimodal Support**: Retrieve text, images, and other data types for comprehensive answers.
+- **Pay-per-use**: Transparent pricing—you only pay for what you use.
+- **Hybrid Search**: Combine proprietary dataset access with web search capabilities.
+- **Built for AI**: Designed specifically for Retrieval-Augmented Generation (RAG) applications.
+
+## Installation
+
+Install the Valyu SDK via npm:
+
+```bash
+npm install valyu
+```
+
+Quick Start
+```js
+const { Valyu } = require('valyu');
+
+// Initialize the Valyu client (provide your API key)
+const valyu = new Valyu("your-api-key");
+
+// Get relevant context for your query
+(async () => {
+  const response = await valyu.context(
+    "Tell me about ancient civilizations", // query
+    "proprietary",                         // search_type ("proprietary" or "web")
+    5,                                     // num_query: number of queries to generate
+    3,                                     // num_results: number of results per query
+    10                                     // max_price: maximum price per thousand queries
+  );
+  console.log(response);
+})();
+```
+

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "valyu-js",
+    "version": "1.0.0",
+    "description": "We handle the data. You handle the AI.",
+    "main": "index.js",
+    "scripts": {
+      "test": "node test.js"
+    },
+    "repository": {
+      "type": "git",
+      "url": "git+https://github.com/ValyuNetwork/valyu-js.git"
+    },
+    "keywords": [
+      "ai",
+      "sdk",
+      "rag",
+      "valyu"
+    ],
+    "author": "Valyu",
+    "license": "MIT",
+    "bugs": {
+      "url": "https://github.com/ValyuNetwork/valyu-js/issues"
+    },
+    "homepage": "https://valyu.network",
+    "dependencies": {
+      "axios": "^1.4.0"
+    }
+  }
+  

package/src/api.js

@@ -0,0 +1,136 @@
+// src/api.js
+
+const axios = require('axios');
+
+/**
+ * Valyu API Client.
+ */
+class Valyu {
+  /**
+   * Initialize the Valyu client.
+   *
+   * @param {string} [apiKey] - The API key to use for the client.
+   *   If not provided, the environment variable `VALYU_API_KEY` is used.
+   * @param {string} [baseUrl="https://api.valyu.network/v1"] - The base URL for the Valyu API.
+   *
+   * @throws {Error} If no API key is provided.
+   */
+  constructor(apiKey, baseUrl = "https://api.valyu.network/v1") {
+    if (!apiKey) {
+      apiKey = process.env.VALYU_API_KEY;
+      if (!apiKey) {
+        throw new Error("VALYU_API_KEY is not set");
+      }
+    }
+    this.baseUrl = baseUrl;
+    this.headers = {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey
+    };
+  }
+
+  /**
+   * Fetch context from the Valyu API.
+   *
+   * @param {string} query - The query to search for.
+   * @param {"web"|"proprietary"} search_type - The type of search to perform.
+   * @param {number} [max_num_results=10] - The maximum number of results to return.
+   * @param {boolean} [query_rewrite=true] - Whether to rewrite the query to improve search quality.
+   * @param {number} [similarity_threshold=0.4] - The similarity threshold to not return results below.
+   * @param {number} [max_price=1] - The maximum price (per thousand queries) to spend on the search.
+   * @param {string[]} [data_sources] - Optional list of data sources.
+   *
+   * @returns {Promise<SearchResponse>} The search response.
+   */
+  async context(
+    query,
+    search_type,
+    max_num_results = 10,
+    query_rewrite = true,
+    similarity_threshold = 0.4,
+    max_price = 1,
+    data_sources
+  ) {
+    try {
+      const payload = {
+        query,
+        search_type,
+        max_num_results,
+        query_rewrite,
+        similarity_threshold,
+        max_price
+      };
+
+      if (data_sources !== undefined) {
+        payload.data_sources = data_sources;
+      }
+
+      const response = await axios.post(
+        `${this.baseUrl}/knowledge`,
+        payload,
+        { headers: this.headers }
+      );
+
+      if (!response.status || response.status < 200 || response.status >= 300) {
+        return {
+          success: false,
+          error: response.data?.error,
+          tx_id: null,
+          query,
+          results: [],
+          results_by_source: { web: 0, proprietary: 0 },
+          total_deduction_pcm: 0.0,
+          total_deduction_dollars: 0.0,
+          total_characters: 0
+        };
+      }
+
+      return response.data;
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message,
+        tx_id: null,
+        query,
+        results: [],
+        results_by_source: { web: 0, proprietary: 0 },
+        total_deduction_pcm: 0.0,
+        total_deduction_dollars: 0.0,
+        total_characters: 0
+      };
+    }
+  }
+
+  /**
+   * Send feedback about a previous search response.
+   *
+   * @param {string} tx_id - The transaction ID from a previous search response
+   * @param {string} feedback - Feedback message about the search results
+   * @param {"very good"|"good"|"bad"|"very bad"} sentiment - The sentiment of the feedback
+   * @returns {Promise<Object>} Response containing success status and optional error message
+   */
+  async feedback(tx_id, feedback, sentiment) {
+    try {
+      const payload = {
+        tx_id,
+        feedback,
+        sentiment: sentiment.toLowerCase()
+      };
+
+      const response = await axios.post(
+        `${this.baseUrl}/feedback`,
+        payload,
+        { headers: this.headers }
+      );
+
+      return response.data;
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message
+      };
+    }
+  }
+}
+
+module.exports = { Valyu };

package/src/types.js

@@ -0,0 +1,36 @@
+// src/types.js
+
+/**
+ * @typedef {"web" | "proprietary"} SearchType
+ */
+
+/**
+ * @typedef {Object} SearchResult
+ * @property {string} title
+ * @property {string} url
+ * @property {string} content
+ * @property {string} [description]
+ * @property {string} source
+ * @property {number} price
+ * @property {number} length
+ * @property {number} relevance_score
+ */
+
+/**
+ * @typedef {Object} ResultsBySource
+ * @property {number} web
+ * @property {number} proprietary
+ */
+
+/**
+ * @typedef {Object} SearchResponse
+ * @property {boolean} success
+ * @property {string} [error]
+ * @property {string} tx_id
+ * @property {string} query
+ * @property {SearchResult[]} results
+ * @property {ResultsBySource} results_by_source
+ * @property {number} total_deduction_pcm
+ * @property {number} total_deduction_dollars
+ * @property {number} total_characters
+ */

package/tests/test.js

@@ -0,0 +1,39 @@
+const { Valyu } = require('../src/api');
+const assert = require('assert');
+
+async function runTests() {
+  console.log('Running Valyu SDK tests...');
+
+  // Test constructor
+  console.log('\nTesting constructor...');
+  try {
+    const valyu = new Valyu('H5TkbtiBau8WZDkthZZAlqp695btCXk9kZFiG2W9');
+    assert(valyu instanceof Valyu, 'Should create Valyu instance');
+    console.log('✓ Constructor test passed');
+  } catch (e) {
+    console.error('✗ Constructor test failed:', e.message);
+  }
+
+  // Test API call
+  console.log('\nTesting API call...');
+  try {
+    const valyu = new Valyu('H5TkbtiBau8WZDkthZZAlqp695btCXk9kZFiG2W9');
+    const response = await valyu.context(
+      'Test query',
+      'web',
+      1,
+      1,
+      10
+    );
+    
+    // Verify response structure
+    assert(typeof response === 'object', 'Response should be an object');
+    assert('success' in response, 'Response should have success field');
+    assert('results' in response, 'Response should have results field');
+    console.log('✓ API call test passed');
+  } catch (e) {
+    console.error('✗ API call test failed:', e.message);
+  }
+}
+
+runTests().catch(console.error);