Server-side Integration

import AddisAI from "addisai";
import express from "express";

const app = express();
app.use(express.json());
const addis = new AddisAI();

app.post('/api/chat', async (req, res) => {
  const { message } = req.body;

  try {
    const response = await addis.chat.completions.create({
      messages: [{ role: "user", content: message }],
      language: "am",
      temperature: 0.7,
    });

    res.json({
      response_text: response.choices[0].message.content,
      usage: response.usage,
    });
  } catch (error) {
    res.status(500).json({ error: "Internal Server Error" });
  }
});

app.listen(3000, () => console.log('Server running on port 3000'));

from addisai import AddisAI
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
addis = AddisAI()

class ChatRequest(BaseModel):
    message: str

@app.post("/api/chat")
def chat_handler(req: ChatRequest):
    response = addis.chat.completions.create(
        messages=[{"role": "user", "content": req.message}],
        language="am",
        temperature=0.7,
    )
    return {
        "response_text": response["choices"][0]["message"]["content"],
        "usage": response.get("usage"),
    }

package main

import (
	"bytes"
	"encoding/json"
	"net/http"
	"os"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	apiKey := os.Getenv("ADDIS_AI_KEY")

	r.POST("/api/chat", func(c *gin.Context) {
		var input struct {
			Message string `json:"message"`
		}
		if err := c.BindJSON(&input); err != nil { return }

		payload := map[string]interface{}{
			"model": "Addis-፩-አሌፍ",
			"prompt": input.Message,
			"target_language": "am",
		}
		jsonValue, _ := json.Marshal(payload)

		req, _ := http.NewRequest("POST", "https://api.addisassistant.com/api/v1/chat_generate", bytes.NewBuffer(jsonValue))
		req.Header.Set("Content-Type", "application/json")
		req.Header.Set("X-API-Key", apiKey)

		client := &http.Client{}
		resp, err := client.Do(req)
        // Error handling omitted for brevity
		defer resp.Body.Close()

		var result map[string]interface{}
		json.NewDecoder(resp.Body).Decode(&result)
		c.JSON(resp.StatusCode, result)
	})
	r.Run()
}

use Illuminate\Support\Facades\Http;
use Illuminate\Http\Request;

Route::post('/api/chat', function (Request $request) {
    $response = Http::withHeaders([
        'X-API-Key' => env('ADDIS_AI_KEY'),
        'Content-Type' => 'application/json',
    ])->post('https://api.addisassistant.com/api/v1/chat_generate', [
        'model' => 'Addis-፩-አሌፍ',
        'prompt' => $request->input('message'),
        'target_language' => 'am'
    ]);

    return response()->json($response->json(), $response->status());
});

app.post('/api/chat/stream', async (req, res) => {
  const { message } = req.body;

  try {
    const stream = await addis.chat.completions.create({
      messages: [{ role: "user", content: message }],
      language: "am",
      stream: true,
    });

    res.setHeader('Content-Type', 'application/x-ndjson');
    res.setHeader('Transfer-Encoding', 'chunked');

    for await (const event of stream) {
      res.write(JSON.stringify(event) + "\n");
    }
    res.end();
  } catch (error) {
    res.status(500).end();
  }
});

import json
from fastapi.responses import StreamingResponse

@app.post("/api/chat/stream")
def chat_stream(req: ChatRequest):
    stream = addis.chat.completions.create(
        messages=[{"role": "user", "content": req.message}],
        language="am",
        stream=True,
    )

    def iter_stream():
        for event in stream:
            yield json.dumps(event) + "\n"

    return StreamingResponse(
        iter_stream(),
        media_type="application/x-ndjson",
    )