API Reference

Key Features

• Project & Session Management: Create projects, upload resources, manage AI agent sessions
• Token Tracking: Real-time monitoring of AI token usage and cost management
• API Key Security: Argon2-based key management with rate limiting and lockout protection
• Device Registration: Hardware fingerprinting for license compliance and security
• Local Development: Complete local server with configurable ports and offline capability

Endpoints

🔹 Project & Session

• POST /projects → Create project
• GET /projects → List projects
• POST /projects/{id}/resources → Upload resource
• POST /sessions → Start session

🔹 Token Tracking

• GET /sessions/{id}/usage → Check usage
• POST /usage/report → Report tokens

🔹 API Key Security

• POST /apikey/validate → Validate API key (Argon2 + lockout)

🔹 Device Registration

• POST /devices/register → Register device fingerprint
• GET /devices/{user_id} → List devices

🔹 Local Development

• GET /config → Get server config
• POST /config → Update config

🔹 Chat Agent

• POST /chat/send → Send message
• POST /chat/sendfile → Send file
• GET /chat/{id}/history → Get chat history
• GET /chat/{id}/receive → Poll agent reply

🔹 Worker Agents

• POST /workers/start → Start worker agent
• POST /workers/stop → Stop worker agent
• GET /workers/{id} → List workers for a session

FastAPI for Developers

For developers who are not familiar with FastAPI or the associated ecosystem, we've provided a brief overview of its main features to help with understanding how the G6 API endpoints work and how to interface with them.

FastAPI is a modern, high-performance web framework for building APIs with Python. It is designed with ease of use, speed, and robustness in mind. Here's why developers gravitate toward FastAPI:

• Type Hints: FastAPI uses Python type hints for data validation, meaning you get automatic, robust data checking, clear documentation, and editor support (like autocompletion).
• Performance: It's built on top of Starlette and Pydantic, and it's one of the fastest Python web frameworks available.
• Asynchronous: Async-first design lets you build highly concurrent APIs out of the box.
• Automatic Documentation: Every FastAPI project gets interactive API docs by default, powered by OpenAPI (SwaggerUI).

Example: A Minimal FastAPI App

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

You run this with a server such as Uvicorn, for example:

uvicorn main:app --reload

• The API will be live at: http://127.0.0.1:8000
• Docs automatically available at: http://127.0.0.1:8000/docs

---

Using SwaggerUI with FastAPI

The G6Solver API uses SwaggerUI to provide a comprehensive documentation and testing interface for the API endpoints. This is available by running the G6Solver desktop application and directly accessing the localhost port (see system > settings > developers) and then navigating to this page. From here you can view comprehensive documentation and directly access the API using a GUI via the browser window using SwaggerUI by navigating to the /docs endpoint.

SwaggerUI is an interactive web interface that lets you view, test, and interact with your API endpoints in real-time, directly from the browser. FastAPI automatically provides SwaggerUI at /docs for any app you build.

We strongly recommend for developers to build on top of our API using FastAPI/SwaggerUI.

This is especially so if you intend to share your code/open source your code.

Here is what this means in practice:

• Self-Documenting APIs: As soon as you write your endpoints (using Python type hints), FastAPI creates an OpenAPI (Swagger) spec. This is used to generate interactive documentation.
• Interactive Testing: You (or anyone using your API) can execute requests, try parameters, and see real-time responses via a web browser—making development, debugging, and onboarding easier.
• Always Up to Date: Your documentation always matches your code—no manual doc sync needed.

---

Summary Table