# What Programming Languages Are Used in Semantica AGI?

> Discover the programming languages powering Semantica AGI. Learn how Python, TypeScript, JavaScript, YAML, and JSON build its AI core, backend, and web UI.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: getting-started
- Published: 2026-08-13

---

**Semantica AGI is built primarily with Python for its AI core and backend services, complemented by TypeScript and JavaScript for the Explorer web UI, with YAML and JSON handling configuration and data interchange.**

Understanding the programming languages used in Semantica AGI helps developers navigate its multi-language architecture. This open-source repository combines a Python-centric backend engine with a modern React-based frontend, utilizing specific languages for distinct architectural layers. The codebase demonstrates clear separation between the AI orchestration layer and the interactive visualization interface.

## Python-Based Core Framework

The **Python** programming language forms the foundation of Semantica AGI, powering all backend services and the core AI framework. According to the [`pyproject.toml`](https://github.com/semantica-agi/semantica/blob/main/pyproject.toml) file, the project requires Python 3.8 or higher and declares dependencies for graph storage, LLM providers, and vector-store integrations.

The command-line interface and orchestration logic reside in [`semantica/cli.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/cli.py), which serves as the primary entry point for building knowledge bases. This file implements functions like `_jecho` and `_pprint` for JSON output formatting, demonstrating Python's role in both business logic and data serialization.

```python
from semantica import Semantica

# Initialize the framework with default configuration

sem = Semantica()

# Build the knowledge base from all files under `data/`

stats = sem.build_knowledge_base(sources=["data/"])
print("Processed sources:", stats.get("statistics", {}))

```

## TypeScript and JavaScript Frontend

The **Explorer dashboard** relies on **TypeScript** for build configuration and source files, while utilizing **JavaScript** for specific runtime modules. This modern web stack enables the interactive visualization of knowledge graphs through a Vite-powered build pipeline.

The TypeScript configuration in [`explorer/vite.config.ts`](https://github.com/semantica-agi/semantica/blob/main/explorer/vite.config.ts) defines the development server with proxy settings to the Python backend on port 8000. Meanwhile, [`explorer/src/store/edgePairKeys.js`](https://github.com/semantica-agi/semantica/blob/main/explorer/src/store/edgePairKeys.js) provides JavaScript utilities for managing graph edge relationships in the frontend state.

```typescript
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import path from 'path';

export default defineConfig({
  plugins: [react()],
  server: {
    proxy: {
      '/api': { target: 'http://127.0.0.1:8000', changeOrigin: true },
    },
  },
  build: {
    outDir: path.resolve(__dirname, '../semantica/static'),
    target: 'esnext',
  },
});

```

## Configuration and Data Formats

Beyond executable code, Semantica AGI employs **YAML** and **JSON** for declarative configuration. The [`docker-compose.yml`](https://github.com/semantica-agi/semantica/blob/main/docker-compose.yml) file orchestrates multi-container deployments using YAML syntax, while various CLI operations in [`semantica/cli.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/cli.py) output structured JSON for programmatic consumption.

These formats bridge the Python backend and TypeScript frontend, enabling type-safe data interchange between the knowledge graph engine and the web interface.

## Summary

- **Python** (≥3.8) drives the core AI framework, CLI tools, and backend services including LLM integrations and graph store adapters.
- **TypeScript** configures the Vite build pipeline and provides type safety for the Explorer web interface components.
- **JavaScript** handles specific frontend utilities such as edge pair key management in the knowledge graph visualization.
- **YAML** defines Docker Compose orchestration and packaging metadata, while **JSON** serves as the primary data interchange format between backend and frontend systems.

## Frequently Asked Questions

### Is Semantica AGI written entirely in Python?

No, while the core AI engine and backend services are implemented in Python, the project includes a separate web-based Explorer interface built with TypeScript and JavaScript. The Python layer handles knowledge graph construction and LLM orchestration, while the TypeScript frontend provides interactive visualization capabilities.

### What Python version is required to run Semantica AGI?

The project requires **Python 3.8 or higher**, as specified in [`pyproject.toml`](https://github.com/semantica-agi/semantica/blob/main/pyproject.toml). This version requirement ensures compatibility with modern async/await patterns and type hinting features used throughout the orchestrator and CLI modules.

### Why does Semantica AGI use both TypeScript and JavaScript for the frontend?

**TypeScript** is used for build configuration files like [`vite.config.ts`](https://github.com/semantica-agi/semantica/blob/main/vite.config.ts) and React components where type safety is beneficial, while **JavaScript** is employed for specific utility modules such as [`edgePairKeys.js`](https://github.com/semantica-agi/semantica/blob/main/edgePairKeys.js). This hybrid approach allows the project to leverage TypeScript's compile-time checking where valuable while maintaining flexibility for simpler scripts.

### Where is the main entry point for the Semantica AGI CLI?

The command-line interface entry point is located in [`semantica/cli.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/cli.py). This Python module initializes the Semantica framework, parses arguments, and exposes methods for building knowledge bases from local directories through the `Semantica()` class interface.