Skip to main content

Code Examples

This page provides ready-to-use code examples for common use cases with our AI API. Copy and paste these examples to quickly integrate our API into your applications.

JavaScript / Node.js Examples​

Text Completion with Node.js​

const axios = require('axios');

async function generateTextCompletion() {
  try {
    const response = await axios.post('https://api.graphine.ai/api/v1/completions/text', {
      prompt: 'Explain quantum computing in simple terms.',
      // Optional parameters
      // system_prompt: 'You are an expert in quantum physics.',
      // model: 'advanced-model'
    }, {
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    });

    console.log('Generated text:');
    console.log(response.data.data.text);
    console.log('\nMetadata:');
    console.log(response.data.data.metadata);
  } catch (error) {
    console.error('Error generating text completion:', error.response ? error.response.data : error.message);
  }
}

generateTextCompletion();

Chat Completion with Browser JavaScript​

// In a browser environment using fetch
async function generateChatCompletion() {
  const messages = [
    { role: 'system', content: 'You are a helpful assistant that specializes in coding.' },
    { role: 'user', content: 'How do I create a simple HTTP server in Node.js?' }
  ];

  try {
    const response = await fetch('https://api.graphine.ai/api/v1/completions/chat', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_API_KEY'
      },
      body: JSON.stringify({ messages })
    });

    const data = await response.json();
    
    if (data.success) {
      const message = data.data.choices[0].message;
      console.log(`${message.role}: ${message.content}`);
      
      // Token usage information
      console.log('Token usage:', data.data.usage);
    } else {
      console.error('API request failed:', data);
    }
  } catch (error) {
    console.error('Error:', error);
  }
}

React Component for Chat Interface​

import React, { useState, useEffect, useRef } from 'react';
import axios from 'axios';

function ChatInterface() {
  const [messages, setMessages] = useState([
    { role: 'system', content: 'You are a helpful assistant.' }
  ]);
  const [input, setInput] = useState('');
  const [isLoading, setIsLoading] = useState(false);
  const messagesEndRef = useRef(null);

  const scrollToBottom = () => {
    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
  };

  useEffect(() => {
    scrollToBottom();
  }, [messages]);

  const sendMessage = async () => {
    if (!input.trim()) return;
    
    // Add user message to the chat
    const userMessage = { role: 'user', content: input };
    const updatedMessages = [...messages, userMessage];
    setMessages(updatedMessages);
    setInput('');
    setIsLoading(true);
    
    try {
      const response = await axios.post('https://api.graphine.ai/api/v1/completions/chat', {
        messages: updatedMessages
      }, {
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer YOUR_API_KEY'
        }
      });
      
      // Add assistant's response to the chat
      if (response.data.success) {
        const assistantMessage = response.data.data.choices[0].message;
        setMessages([...updatedMessages, assistantMessage]);
      }
    } catch (error) {
      console.error('Error sending message:', error);
      // Add error message to the chat
      setMessages([
        ...updatedMessages, 
        { role: 'assistant', content: 'Sorry, I encountered an error processing your request.' }
      ]);
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <div className="chat-container">
      <div className="messages-container">
        {messages.map((msg, index) => (
          msg.role !== 'system' && (
            <div key={index} className={`message ${msg.role}`}>
              <div className="message-content">{msg.content}</div>
            </div>
          )
        ))}
        {isLoading && (
          <div className="message assistant">
            <div className="message-content">Thinking...</div>
          </div>
        )}
        <div ref={messagesEndRef} />
      </div>
      
      <div className="input-container">
        <input
          type="text"
          value={input}
          onChange={(e) => setInput(e.target.value)}
          onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
          placeholder="Type your message..."
          disabled={isLoading}
        />
        <button onClick={sendMessage} disabled={isLoading}>
          Send
        </button>
      </div>
    </div>
  );
}

export default ChatInterface;

Python Examples​

Text Completion with Python​

import requests

def generate_text_completion(prompt, api_key, system_prompt=None, model=None):
    url = "https://api.graphine.ai/api/v1/completions/text"
    
    payload = {
        "prompt": prompt
    }
    
    if system_prompt:
        payload["system_prompt"] = system_prompt
    
    if model:
        payload["model"] = model
    
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()  # Raise exception for HTTP errors
        
        data = response.json()
        if data["success"]:
            return data["data"]["text"], data["data"]["metadata"]
        else:
            return None, {"error": "API returned success: false"}
    
    except requests.exceptions.RequestException as e:
        return None, {"error": str(e)}

# Example usage
api_key = "YOUR_API_KEY"
prompt = "Write a poem about artificial intelligence."

text, metadata = generate_text_completion(prompt, api_key)
if text:
    print("Generated Text:")
    print(text)
    print("\nMetadata:")
    for key, value in metadata.items():
        print(f"{key}: {value}")
else:
    print("Error:", metadata["error"])

Chat Completion with Python Flask Application​

from flask import Flask, request, jsonify, render_template
import requests
import os

app = Flask(__name__)

# Get API key from environment variable
API_KEY = os.environ.get("AI_API_KEY")
API_URL = "https://api.graphine.ai/api/v1/completions/chat"

@app.route("/")
def index():
    return render_template("chat.html")

@app.route("/api/chat", methods=["POST"])
def chat():
    data = request.json
    messages = data.get("messages", [])
    
    # Ensure system message is present
    if not any(msg.get("role") == "system" for msg in messages):
        messages.insert(0, {
            "role": "system",
            "content": "You are a helpful assistant."
        })
    
    try:
        response = requests.post(
            API_URL,
            json={"messages": messages},
            headers={
                "Content-Type": "application/json",
                "Authorization": f"Bearer {API_KEY}"
            }
        )
        
        response.raise_for_status()
        return jsonify(response.json())
    
    except requests.exceptions.RequestException as e:
        return jsonify({
            "success": False,
            "error": str(e)
        }), 500

if __name__ == "__main__":
    app.run(debug=True)

PHP Examples​

Text Completion with PHP​

<?php
function generateTextCompletion($prompt, $apiKey, $systemPrompt = null, $model = null) {
    $url = "https://api.graphine.ai/api/v1/completions/text";
    
    $payload = [
        "prompt" => $prompt
    ];
    
    if ($systemPrompt) {
        $payload["system_prompt"] = $systemPrompt;
    }
    
    if ($model) {
        $payload["model"] = $model;
    }
    
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "Content-Type: application/json",
        "Authorization: Bearer " . $apiKey
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        $data = json_decode($response, true);
        if ($data["success"]) {
            return [
                "text" => $data["data"]["text"],
                "metadata" => $data["data"]["metadata"]
            ];
        } else {
            return ["error" => "API returned success: false"];
        }
    } else {
        return ["error" => "HTTP Error: " . $httpCode];
    }
}

// Example usage
$apiKey = "YOUR_API_KEY";
$prompt = "Write a short story about a robot learning to paint.";

$result = generateTextCompletion($prompt, $apiKey);
if (isset($result["text"])) {
    echo "Generated Text:\n";
    echo $result["text"] . "\n\n";
    echo "Metadata:\n";
    foreach ($result["metadata"] as $key => $value) {
        echo $key . ": " . json_encode($value) . "\n";
    }
} else {
    echo "Error: " . $result["error"] . "\n";
}
?>

Working with API Credits​

Checking Credit Balance (JavaScript)​

const axios = require('axios');

async function checkCreditPurchaseHistory() {
  try {
    const response = await axios.get('https://your-api-domain.com/api/v1/credits/history', {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    });

    const data = response.data.data;
    
    console.log('Credit Summary:');
    console.log(`Total Credits Purchased: ${data.summary.total_credits_purchased}`);
    console.log(`Current API Credits: ${data.summary.current_api_credits}`);
    console.log(`Total Spent: ${data.summary.total_spent}`);
    
    console.log('\nPurchase History:');
    data.purchases.forEach(purchase => {
      console.log(`- ${purchase.package_name}: ${purchase.credits} credits`);
      console.log(`  Date: ${purchase.created_at}`);
      console.log(`  Status: ${purchase.status}`);
      console.log(`  Amount: ${purchase.amount_paid} ${purchase.currency}`);
      console.log('---');
    });
  } catch (error) {
    console.error('Error checking credit history:', error.response ? error.response.data : error.message);
  }
}

checkCreditPurchaseHistory();

Creating Checkout Session (Python)​

import requests
from flask import Flask, redirect, request

app = Flask(__name__)

API_KEY = "YOUR_API_KEY"
API_URL = "https://your-api-domain.com/api/v1/credits/checkout"
BASE_URL = "https://your-app-domain.com"

@app.route("/purchase/<package_id>")
def purchase_credits(package_id):
    payload = {
        "package_id": package_id,
        "success_url": f"{BASE_URL}/payment/success",
        "cancel_url": f"{BASE_URL}/payment/cancel"
    }
    
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {API_KEY}"
    }
    
    try:
        response = requests.post(API_URL, json=payload, headers=headers)
        response.raise_for_status()
        
        data = response.json()
        if data["success"]:
            # Redirect user to checkout page
            return redirect(data["data"]["checkout_url"])
        else:
            return "Failed to create checkout session", 400
    
    except requests.exceptions.RequestException as e:
        return f"Error: {str(e)}", 500

@app.route("/payment/success")
def payment_success():
    # Handle successful payment
    return render_template("payment_success.html")

@app.route("/payment/cancel")
def payment_cancel():
    # Handle canceled payment
    return render_template("payment_cancel.html")

if __name__ == "__main__":
    app.run(debug=True)

Error Handling Examples​

Comprehensive Error Handling (JavaScript)​

const axios = require('axios');

async function makeApiRequest(endpoint, method, data = null) {
  const url = `https://your-api-domain.com/api/v1/${endpoint}`;
  const config = {
    method: method,
    url: url,
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${process.env.API_KEY}`
    }
  };
  
  if (data && (method === 'post' || method === 'put')) {
    config.data = data;
  }
  
  try {
    const response = await axios(config);
    return {
      success: true,
      data: response.data
    };
  } catch (error) {
    // Handle different types of errors
    if (error.response) {
      // The server responded with a status code outside the 2xx range
      const statusCode = error.response.status;
      let errorMessage = 'An error occurred with the API request.';
      
      switch (statusCode) {
        case 400:
          errorMessage = 'Bad request. Please check your input parameters.';
          break;
        case 401:
          errorMessage = 'Unauthorized. Please check your API key.';
          break;
        case 403:
          errorMessage = 'Forbidden. You may not have enough credits or permissions.';
          break;
        case 404:
          errorMessage = 'Resource not found.';
          break;
        case 429:
          errorMessage = 'Rate limit exceeded. Please try again later.';
          break;
        case 500:
          errorMessage = 'Server error. Please try again later.';
          break;
        default:
          errorMessage = `API error with status code ${statusCode}.`;
      }
      
      return {
        success: false,
        error: {
          message: errorMessage,
          status: statusCode,
          details: error.response.data
        }
      };
    } else if (error.request) {
      // The request was made but no response was received
      return {
        success: false,
        error: {
          message: 'No response received from the server. Please check your network connection.',
          details: error.request
        }
      };
    } else {
      // Something happened in setting up the request
      return {
        success: false,
        error: {
          message: 'Error setting up the request.',
          details: error.message
        }
      };
    }
  }
}

// Example usage
async function main() {
  // Example 1: Make a text completion request
  const textResult = await makeApiRequest('completions/text', 'post', {
    prompt: 'Write a short story about AI.'
  });
  
  if (textResult.success) {
    console.log('Text Completion Result:');
    console.log(textResult.data.data.text);
  } else {
    console.error('Text Completion Error:');
    console.error(textResult.error.message);
  }
  
  // Example 2: Get available models
  const modelsResult = await makeApiRequest('models', 'get');
  
  if (modelsResult.success) {
    console.log('Available Models:');
    modelsResult.data.data.forEach(model => {
      console.log(`- ${model.name} (${model.model_name}): ${model.description}`);
    });
  } else {
    console.error('Models Error:');
    console.error(modelsResult.error.message);
  }
}

main().catch(console.error);