# Getting started with Zontroy AI
## *Welcome to Zontroy AI!*
*This is Zontroy Documentation that explains Zontroy AI to generate code in any programming language and how Zontroy AI software can reduce software costs. Zontroy writes code in developer's coding style as a ghost programmer and speeds up software developers extremely.*
# Zontroy AI
Your Ghost Programmer
### Getting Started with Zontroy AI
Zontroy AI represents a revolutionary leap in developer productivity, seamlessly\
integrating the strongest capabilities from today's leading AI systems into a unified development platform. This comprehensive guide will help you understand what Zontroy AI offers and how it can transform your development workflow.
### What is Zontroy AI?
Zontroy AI is an advanced development platform that combines the capabilities of\
multiple leading AI systems—including Claude, ChatGPT, Gemini, Llama, Deep Seek, Qwen, and xAI—into a single, powerful toolkit designed specifically for developers. By leveraging the unique strengths of each AI system, Zontroy AI provides an unprecedented level of assistance throughout the development process.
Unlike traditional development tools that offer limited AI capabilities, Zontroy AI creates a seamless ecosystem where developers can interact with AI in natural language, generate complete code files, and even orchestrate teams of specialized AI agents to tackle complex programming challenges. This multi-model approach ensures that developers always have access to the most appropriate AI capabilities for any given task.
### Core Features
Zontroy AI's platform is built around several groundbreaking features that work togethe to enhance developer productivity:
#### Chat
The Chat feature enables developers to generate precise programming outputs by leveraging natural language prompts. This interactive interface allows you to ask coding questions, request explanations, and receive immediate assistance directly within your development environment. By selecting your preferred AI model, you can tailor the responses to your specific needs and preferences, ensuring that you always get the most relevant and accurate information.
#### Collaborator
Taking AI assistance to the next level, the Collaborator functionality elevates your\
development experience by creating and implementing complete code files based on your specifications. Rather than simply providing code snippets or answers to specific questions, Collaborator understands the broader context of your project and can generate entire files that integrate seamlessly with your existing codebase. This feature dramatically accelerates development by handling routine coding tasks while you focus on higher-level design and architecture decisions.
#### Peerer
With Peerer, Zontroy orchestrates multi-agent AI teams that combine specialized\
strengths from various models to tackle complex programming tasks end-to-end. This revolutionary approach allows different AI models to collaborate, each contributing their unique capabilities to solve problems that would be challenging for any single model. By creating a virtual team of AI specialists, Peerer can handle sophisticated development tasks with remarkable efficiency and creativity.
#### Model Context Protocol (MCP) Tools
Zontroy's innovative Model Context Protocol (MCP) Tools optimize interactions between different AI systems, ensuring coherent and efficient collaboration. These tools manage the flow of information between models, maintain context across multiple interactions, and ensure that each AI system receives the inputs it needs to perform optimally. By creating a standardized protocol for AI communication, MCP Tools enable seamless integration of diverse models into a unified development experience.
#### Offline Code Generator
For developers working in sensitive environments or with limited connectivity, Zontroy offers a powerful Code Generator that operates entirely offline using Zontroy's proprietary programming language. This feature eliminates server dependencies and ensures both performance and privacy for mission-critical development work. The Offline Code Generator can handle varying levels of complexity, from simple entities to unlimited structures, depending on your subscription tier.
*Well-Known Frameworks*
*Zontroy Offline Code Generator is a versatile tool that supports a wide range of frameworks, making it a valuable resource for developers across various domains. Whether you're working on web development, mobile apps, or backend systems, Zontroy Code Generator has you covered.*
Backend and Frontend Frameworks
*It seamlessly integrates with popular frontend frameworks like React, Angular, and Vue.js, enabling rapid UI development. On the backend, it supports frameworks like Node.js, Django, Ruby on Rails, and Laravel, streamlining server-side logic implementation. Additionally, Zontroy Code Generator extends its capabilities to mobile app development by providing support for React Native and Flutter, making it a comprehensive solution for cross-platform application development. This extensive framework compatibility ensures that developers can harness its code generation power across a multitude of project types and technologies.*
# Why Choose Zontroy AI?
Zontroy AI is at the forefront of revolutionizing developer productivity by seamlessly integrating the most advanced AI systems available today. By combining the strengths of leading AI models such as Claude, ChatGPT, Gemini, Llama, Deep Seek, Qwen, and xAI, Zontroy AI offers a unified development platform that empowers programmers to achieve more with less effort.
# Free AI Models Integration
One of the standout features of Zontroy AI is its free integration of top-tier AI models. This means developers can leverage the capabilities of multiple AI systems without additional costs, making it an incredibly cost-effective solution for enhancing coding efficiency. Whether you need assistance with code generation, debugging, or optimizing algorithms, Zontroy AI provides the tools you need at no extra charge.
In Addition to free AI models integration feature, Zontroy AI offers something truly unique in the market: **free integration with all major AI models** without additional costs or hidden fees. While other platforms lock you into their proprietary AI systems or charge premium fees for access to advanced models, Zontroy AI puts the power of choice in your hands:
* **Zero Additional Costs**: Use your existing API keys from OpenAI, Anthropic, Google, DeepSeek, Qwen, xAI, and Llama without paying Zontroy any extra fees or markups
* **Model Flexibility**: Switch seamlessly between different AI models based on your specific task requirements
* **Future-Proof Development**: As new AI models emerge, Zontroy AI rapidly integrates them, ensuring you always have access to cutting-edge capabilities
* **Cost Optimization**: Select more affordable models for routine tasks while reserving premium models for complex challenges, significantly reducing your overall AI expenditure
This approach delivers substantial financial benefits for developers and organizations of all sizes. By eliminating the "middleman markup" common with other platforms, Zontroy AI users typically report 30-50% cost savings on their AI-assisted development compared to competing solutions.
# Free for Students
Zontroy AI is deeply committed to supporting the next generation of developers through our industry-leading **Student Program**:
* **Two Years Completely Free**: Verified students receive full access to Zontroy AI Basic tier for 24 months at absolutely no cost
* **No Feature Restrictions**: Unlike other platforms that limit student access, we provide complete, unrestricted access to Basic features
* **Simple Verification**: Easy verification process using your educational email address.
This program represents our investment in the future of software development, ensuring that students can build their skills using the same professional tools used in industry. With students already enrolled worldwide, Zontroy AI is becoming the standard AI development platform in educational institutions across the globe.
# Technical Advantages
Beyond our pricing and accessibility benefits, Zontroy AI delivers technical advantages that directly impact developer productivity and code quality:
#### Offline Code Generation
Our proprietary offline code generator operates entirely on your local machine, providing:
* **Unmatched Privacy**: Generate code for sensitive projects without sending data to external servers
* **Reliable Performance**: Work productively even in environments with limited or no internet connectivity
* **Consistent Results**: Deterministic generation produces reliable, predictable code outputs
* **Resource Efficiency**: Optimized algorithms run efficiently on standard hardware without requiring cloud resources
#### Model Context Protocol (MCP) Tools
Zontroy's innovative MCP Tools represent a technological breakthrough in AI collaboration:
* **Context Preservation**: Maintain perfect context when switching between different AI models
* **Optimized Interactions**: Automatically route tasks to the most appropriate AI model based on specialization
* **Reduced Redundancy**: Eliminate the need to repeat information when transitioning between models
* **Enhanced Consistency**: Ensure uniform coding standards and patterns across all AI-generated code
#### Multi-Agent Collaboration with Peerer
The revolutionary Peerer feature transforms how complex development tasks are approached:
* **Specialized AI Teams**: Create virtual development teams with AI models assigned to specialized roles
* **Parallel Processing**: Tackle different aspects of complex problems simultaneously
* **Complementary Strengths**: Leverage the unique capabilities of different models working in concert
* **Human-Like Collaboration**: Experience a development process that mirrors professional team dynamics
# The Developer's Choice
Zontroy AI has quickly become the preferred AI development platform for professionals who value:
* **Flexibility**: Freedom to use the right AI model for each specific task
* **Economy**: Significant cost savings through our no-markup model integration
* **Privacy**: Control over sensitive code and data with offline processing options
* **Productivity**: Streamlined workflows that eliminate repetitive tasks
* **Quality**: Consistent, high-quality code generation across projects
By combining these advantages with our commitment to accessibility through programs like our Student Initiative, Zontroy AI represents not just the present of AI-assisted development, but its future.Whether you're an individual developer looking to enhance your productivity, a student beginning your programming journey, or an enterprise seeking to transform your development processes, Zontroy AI offers unmatched capabilities, flexibility, and value that will revolutionize how you create software.
# Zontroy AI Quick Start
### Step-by-Step Installation and Setup
Download the Latest Version
* Visit the official Zontroy website at[ https://zontroy.com/](https://zontroy.com/) to download the latest version of Zontroy AI.
Install Zontroy AI
* Locate the downloaded executable file (e.g., Zontroy.AI-2.5.3.exe) on your computer.
* Double-click the file to begin the installation process. Follow the on-screen instructions to complete the setup.
Launch Zontroy AI
* After installation, locate the Zontroy AI shortcut icon on your desktop or in your Start menu.
* Double-click the icon to launch the application.
Access Your User Profile
Once Zontroy AI is running, navigate to the menu bar and select Help > User Profile
Sign Up and Sign In
* If you are a new user, click the Sign Up button to create an account.
* After signing up, log in to activate your 4-week trial version of Zontroy AI.
Start Your Trial
* Upon successful login, the trial version of Zontroy AI will automatically begin.
**Configure API Keys**
Go to Settings > User > AI API to provide API keys for the AI models you wish to use.
Supported AI platforms include:
1. OpenAI
2. Claude (Anthropic)
3. DeepSeek
4. Gemini (Google)
5. Qwen
6. Llama
7. xAI
8. OpenRouter
You can provide one or more API keys to enable access to the relevant AI models.
{% hint style="info" %}
***Good to know:*** You can click on the address to download the Zontroy AI software.
{% endhint %}
# Zontroy AI Chat
The Chat feature stands as one of the cornerstone capabilities of Zontroy AI, providing developers with an intuitive and powerful interface for interacting with multiple AI models through natural language. This section explores the full capabilities, use cases, and best practices for leveraging the Chat feature to enhance your development workflow.
### Overview
Zontroy AI's Chat feature enables developers to generate precise programming outputs by leveraging natural language prompts. Unlike traditional documentation searches or online forums, Chat provides immediate, contextually relevant responses to your coding questions, allowing you to maintain focus and momentum throughout your development process.\
The true power of Zontroy AI's Chat lies in its seamless integration with multiple leading AI models. Rather than limiting you to a single AI system's capabilities, Zontroy AI allows you to select your preferred model for each interaction, ensuring you always have access to the most appropriate AI capabilities for your specific needs.
### Accessing the Chat Interface
The Chat interface is readily accessible from anywhere within the Zontroy AI\
environment:\
1\. Locate the right-hand sidebar in the Zontroy AI interface, where you'll find the main navigation menu.\
2\. Click on the "Chat" option to open the Chat panel.\
3\. The Chat panel features a clean, intuitive interface with a model selection\
dropdown at the top and a message input box at the bottom.\
This persistent accessibility ensures that assistance is always just a few clicks away, regardless of what you're working on within the Zontroy AI environment.
### Selecting Your AI Model
One of the most powerful aspects of Zontroy AI's Chat feature is the ability to choose from a diverse range of AI models, each with its own strengths and specializations. To select your preferred model:
\
1\. Click on the model selection dropdown at the top of the Chat panel.\
2\. Browse through the available models, which may include options from OpenAI,\
Claude (Anthropic), DeepSeek, Gemini (Google), Qwen, Llama, xAI, and OpenRouter.\
3\. Select the model that best suits your current needs or preferences.\
The availability of specific models depends on the API keys you've configured in the Settings > User > AI API section. If a model appears grayed out or unavailable, you may need to provide the corresponding API key to enable access.
\
Different models excel at different types of tasks. For example: - OpenAI's GPT-4.5- preview and GPT-4o models offer excellent general-purpose coding assistance with strong reasoning capabilities. - Claude models from Anthropic provide detailed explanations and can handle longer contexts. - DeepSeek Reasoner excels at complex problem-solving and algorithmic challenges. - Llama models offer strong performance for specific programming languages and frameworks.\
As you become more familiar with the strengths of each model, you can strategically select the most appropriate option for each specific coding challenge.
#### Crafting Effective Prompts
The quality of responses you receive from Zontroy AI's Chat feature depends\
significantly on how you formulate your prompts. Here are some strategies for crafting effective prompts:
**Be Specific and Contextual**\
Provide sufficient context about your project, the programming language you're using, and any relevant constraints or requirements. For example, instead of asking "How do I sort a list?", a more effective prompt might be "How do I implement a stable merge sort algorithm in Python that handles duplicate values efficiently?"\
**Include Relevant Code Snippets**\
When asking about existing code, include the relevant snippets directly in your prompt. This gives the AI model the specific context it needs to provide accurate assistance. For example:\
*I'm getting an error with this React component:*\
`function UserProfile({ userId }) {`\
`const [user, setUser] = useState(null);`\
`useEffect(() => {`\
`fetchUser(userId).then(data => setUser(data));`\
`});`\
`return (`
`{user ?`
## `{user.name}`
`:`
`Loading...`
`});`\
`}`\
*The component keeps re-fetching the user data in an infinite loop. What's causing this and how can I fix it?*
**Specify Your Expected Output Format**
If you have preferences about how the response should be structured, mention them in your prompt. For example: "Please provide the solution as a complete function with comments explaining each step" or "Please explain the concept first, then show an example implementation."
**Iterate and Refine**
Don't hesitate to follow up on responses with clarifying questions or requests for\
modifications. The Chat feature is designed for interactive, iterative conversations that progressively refine solutions to meet your specific needs.
# Zontroy AI Collaborator
The Collaborator feature represents a significant advancement in AI-assisted development, taking Zontroy AI beyond simple chat-based interactions to deliver complete, implementation-ready code files based on developer specifications. This section provides a comprehensive overview of the Collaborator feature, its capabilities, and how to leverage it effectively in your development workflow.\
**Overview**\
While the Chat feature excels at answering specific questions and generating code\
snippets, Collaborator elevates this experience by creating and implementing complete code files based on developer specifications. This powerful capability allows Zontroy AI to understand the broader context of your project and generate entire files that integrate seamlessly with your existing codebase.\
Collaborator functions as a virtual pair programming partner that can take high-level requirements and transform them into production-ready code files. By handling routine coding tasks, Collaborator frees you to focus on higher-level design decisions, architecture planning, and the creative aspects of software development that benefit most from human insight.\
**Prerequisites for Using Collaborator**\
Before using the Collaborator feature, you need to:\
**1. Open a Folder or Workspace:** Collaborator requires access to your project context to generate appropriate files. This context helps the AI understand your project structure, dependencies, and coding conventions.\
**2. Configure API Keys:** Ensure you have configured API keys for your preferred AI\
models in the Settings > User > AI API section. Collaborator leverages these models to generate code files.\
**3. Select a Subscription Tier:** Collaborator is available in the Basic and Advanced\
subscription tiers but is not included in the Starter tier.\
**Accessing the Collaborator Interface**
To access the Collaborator feature:\
1\. Open your project folder or workspace in Zontroy AI.\
2\. Navigate to the right-hand sidebar in the Zontroy AI interface.\
3\. Click on the "Collaborator" option to open the Collaborator panel.\
The Collaborator interface features a model selection dropdown at the top and a\
message input box at the bottom, similar to the Chat interface but with additional\
capabilities specific to file generation.\
**Selecting Your AI Model**\
As with the Chat feature, Collaborator allows you to choose from various AI models based on your specific needs:\
1\. Click on the model selection dropdown at the top of the Collaborator panel.
2\. Browse through the available models from providers like OpenAI, Claude (Anthropic), DeepSeek, Gemini (Google), Qwen, Llama, and xAI.\
3\. Select the model that best suits your current project requirements.\
Different models may excel at generating code for specific languages, frameworks, or types of applications. For example:\ OpenAI's GPT-4.5-preview and GPT-4o models offer excellent general-purpose code generation across multiple languages.\ Claude models from Anthropic may provide more detailed documentation within\
generated files.\ DeepSeek models might excel at generating optimized algorithms and data\
structures.\ Llama models could offer specialized capabilities for certain programming\
paradigms.\
As you gain experience with Collaborator, you'll develop preferences for which models work best for different types of code generation tasks.
# Zontroy AI Peerer
The Peerer feature represents the pinnacle of Zontroy AI's capabilities, introducing a revolutionary approach to AI-assisted development through multi-agent collaboration. This section provides a comprehensive exploration of how Peerer orchestrates teams of specialized AI models to tackle complex programming challenges with unprecedented efficiency and creativity.\
**Overview**\
With Peerer, Zontroy orchestrates multi-agent AI teams that combine specialized\
strengths from various models to tackle complex programming tasks end-to-end. This innovative approach transcends the limitations of single-model interactions by creating a virtual development team where different AI models collaborate, each contributing their unique capabilities to solve problems that would be challenging for any individual model.\
Peerer transforms the development experience from a one-on-one interaction with an AI assistant to a collaborative session with a specialized team of AI agents, each playing distinct roles in the development process. This multi-agent approach mirrors the dynamics of human development teams, where different specialists contribute their expertise to create cohesive, high-quality software solutions.\
**Prerequisites for Using Peerer**\
Before leveraging the power of Peerer, you need to:\
**1. Open a Folder or Workspace:** Like Collaborator, Peerer requires access to your\
project context to understand the environment in which it will be generating code.
### Output Example
```tsx
// PrivateRoutes.tsx.zsif
import {Suspense} from 'react'
import {Route} from 'react-router-dom'
const cityPage = lazy(() => import('../modules/city/cityPage'))
const countryPage = lazy(() => import('../modules/country/countryPage'))
const customerPage = lazy(() => import('../modules/customer/customerPage'))
}
/>
}
/>
}
/>
```
### *Generate in Zontroy IDE*
*Create an Empty Zontroy Project using menu File -> New Project -> Create (Empty Zontroy Project).*
*Add a zsif file into the project*
*Name the file as PrivateRoutes.tsx.zsif or anything you want and click Add File*
*Open newly created zsif file, write the code provided above as an example and save it.*
*Click blue generate button and see the output*
{% hint style="info" %} **Good to know:** *In daily programming, routing, object mapping, dependency injection and context management are sample concepts which for using a single code file.*
{% endhint %}
# Zontroy AI Offline Repeating File
### *zref*
*Zontroy Repeating File is used to create multiple code files and generate lines of code inside those. It uses .zref extension. Name of zref file is set programatically by entering a name in Zontroy Programming Language.*
Multiple entities to multiple code files
### *File Naming Format*
```
[file_name].[file_extension].zref
```
### *File Naming Example*
```
[[[zg-entity...zg-name]]].java.zref
```
### *Code Example*
*A simple usage example of zref file in C#.*
// Izg-singularize(((zg-entity...zg-name)))Service.cs.zref
using Oprazi.Dto.DTOs;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
namespace Oprazi.Bll.Services.IServices
{
public interface Izg-singularize(((zg-entity...zg-name)))Service
{
Task<zg-singularize(((zg-entity...zg-name)))ToResponseDTO> Getzg-pluralize(((zg-entity...zg-name)))(zg-singularize(((zg-entity...zg-name)))ToFilterDTO filter);
Task<zg-singularize(((zg-entity...zg-name)))DTO> Getzg-singularize(((zg-entity...zg-name)))ById(int Id);
Task<zg-singularize(((zg-entity...zg-name)))DTO> Addzg-singularize(((zg-entity...zg-name)))(zg-singularize(((zg-entity...zg-name)))ToAddDTO zg-lower(((zg-singularize(((zg-entity...zg-name))))))ToAddDTO);
Task Updatezg-singularize(((zg-entity...zg-name)))(zg-singularize(((zg-entity...zg-name)))DTO zg-lower(((zg-singularize(((zg-entity...zg-name))))))DTO);
Task Deletezg-singularize(((zg-entity...zg-name)))(int Id);
}
}
### Output Example
```csharp
// IBankService.cs
using Oprazi.Dto.DTOs;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
namespace Oprazi.Bll.Services.IServices
{
public interface IBankService
{
Task GetBanks(BankToFilterDTO filter);
Task GetBankById(int Id);
Task AddBank(BankToAddDTO bankToAddDTO);
Task UpdateBank(BankDTO bankDTO);
Task DeleteBank(int Id);
}
}
```
```csharp
// IBankBranchService.cs
using Oprazi.Dto.DTOs;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
namespace Oprazi.Bll.Services.IServices
{
public interface IBankBranchService
{
Task GetBankBranches(BankBranchToFilterDTO filter);
Task GetBankBranchById(int Id);
Task AddBankBranch(BankBranchToAddDTO bankbranchToAddDTO);
Task UpdateBankBranch(BankBranchDTO bankbranchDTO);
Task DeleteBankBranch(int Id);
}
}
```
```csharp
// IBankAccountService.cs
using Oprazi.Dto.DTOs;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
namespace Oprazi.Bll.Services.IServices
{
public interface IBankAccountService
{
Task GetBankAccounts(BankAccountToFilterDTO filter);
Task GetBankAccountById(int Id);
Task AddBankAccount(BankAccountToAddDTO bankaccountToAddDTO);
Task UpdateBankAccount(BankAccountDTO bankaccountDTO);
Task DeleteBankAccount(int Id);
}
}
```
{% hint style="info" %}
***Good to know:*** *In daily programming, controller, validator, service, repository etc classes are sample classes which for using a repeating code file.*
{% endhint %}
# Zontroy AI Offline Inner Repeating File
## *ziref*
*Zontroy AI Offline Inner Repeating File is used to create folders, multiple code files and generate lines of code inside those. It uses .ziref extension. Name of folders and ziref files is set programatically by entering a name in Zontroy Programming Language.*
Multiple entities to multiple folders and code files
### *Folder Naming Format*
```
[folder_name].ziref
```
### *File Naming Format*
```
[file_name].[file_extension].ziref
```
### *Folder Naming Example*
```
My[[[zg-entity...zg-name]]]Folder.ziref
```
### *File Naming Example*
```
MyClass.java.ziref
```
### *Code Example*
*A simple usage example of ziref file in Typescript.*
```
// folder name
zg-l(((zg-p(((zg-entity...zg-name))))))-list.ziref
```
```typescript
// file name
// _requests.ts.ziref
import axios, {AxiosResponse} from 'axios'
import {ID, Response} from '../../../../../_metronic/helpers'
import {[[[zg-entity...zg-name]]], zg-pluralize(((zg-entity...zg-name)))QueryResponse} from './_models'
const API_URL = process.env.REACT_APP_API_URL
const GET_zg-upper(((zg-entity...zg-name)))_URL = `${API_URL}/zg-lower(((zg-entity...zg-name)))/getzg-lower(((zg-entity...zg-name)))`
const CREATE_zg-upper(((zg-entity...zg-name)))_URL = `${API_URL}/zg-lower(((zg-entity...zg-name)))/addzg-lower(((zg-entity...zg-name)))`
const UPDATE_zg-upper(((zg-entity...zg-name)))_URL = `${API_URL}/zg-lower(((zg-entity...zg-name)))/updatezg-lower(((zg-entity...zg-name)))`
const DELETE_zg-upper(((zg-entity...zg-name)))_URL = `${API_URL}/zg-lower(((zg-entity...zg-name)))/deletezg-lower(((zg-entity...zg-name)))`
const GET_zg-upper(((zg-pluralize(((zg-entity...zg-name))))))_URL = `${API_URL}/zg-lower(((zg-entity...zg-name)))/getzg-lower(((zg-pluralize(((zg-entity...zg-name))))))`
const getzg-pluralize(((zg-entity...zg-name))) = (query: string): Promise => {
return axios
.get(`${GET_zg-upper(((zg-pluralize(((zg-entity...zg-name))))))_URL}?${query}`)
.then((d: AxiosResponse) => d.data)
}
const get[[[zg-entity...zg-name]]]ById = (id: ID): Promise<[[[zg-entity...zg-name]]] | undefined> => {
return axios
.get(`${GET_zg-upper(((zg-entity...zg-name)))_URL}/${id}`)
.then((response: AxiosResponse>) => response.data)
.then((response: Response<[[[zg-entity...zg-name]]]>) => response.data)
}
const create[[[zg-entity...zg-name]]] = (zg-lower(((zg-entity...zg-name))): [[[zg-entity...zg-name]]]): Promise<[[[zg-entity...zg-name]]] | undefined> => {
return axios
.post(CREATE_zg-upper(((zg-entity...zg-name)))_URL, zg-lower(((zg-entity...zg-name))))
.then((response: AxiosResponse>) => response.data)
.then((response: Response<[[[zg-entity...zg-name]]]>) => response.data)
}
const update[[[zg-entity...zg-name]]] = (zg-lower(((zg-entity...zg-name))): [[[zg-entity...zg-name]]]): Promise<[[[zg-entity...zg-name]]] | undefined> => {
return axios
.put(`${UPDATE_zg-upper(((zg-entity...zg-name)))_URL}/${zg-lower(((zg-entity...zg-name))).id}`, zg-lower(((zg-entity...zg-name))))
.then((response: AxiosResponse>) => response.data)
.then((response: Response<[[[zg-entity...zg-name]]]>) => response.data)
}
const delete[[[zg-entity...zg-name]]] = (zg-lower(((zg-entity...zg-name)))Id: ID): Promise => {
return axios.delete(`${DELETE_zg-upper(((zg-entity...zg-name)))_URL}/${zg-lower(((zg-entity...zg-name)))Id}`).then(() => {})
}
const deleteSelectedzg-pluralize(((zg-entity...zg-name))) = (zg-lower(((zg-entity...zg-name)))Ids: Array): Promise => {
const requests = zg-lower(((zg-entity...zg-name)))Ids.map((id) => axios.delete(`${DELETE_zg-upper(((zg-entity...zg-name)))_URL}/${id}`))
return axios.all(requests).then(() => {})
}
export {getzg-pluralize(((zg-entity...zg-name))), delete[[[zg-entity...zg-name]]], deleteSelectedzg-pluralize(((zg-entity...zg-name))), get[[[zg-entity...zg-name]]]ById, create[[[zg-entity...zg-name]]], update[[[zg-entity...zg-name]]]}
```
### *Output Example*
```
// folder
--> expenses-list
```
```typescript
// file
// _requests.ts
import axios, {AxiosResponse} from 'axios'
import {ID, Response} from '../../../../../_metronic/helpers'
import {Expense, ExpensesQueryResponse} from './_models'
const API_URL = process.env.REACT_APP_API_URL
const GET_EXPENSE_URL = `${API_URL}/expense/getexpense`
const CREATE_EXPENSE_URL = `${API_URL}/expense/addexpense`
const UPDATE_EXPENSE_URL = `${API_URL}/expense/updateexpense`
const DELETE_EXPENSE_URL = `${API_URL}/expense/deleteexpense`
const GET_EXPENSES_URL = `${API_URL}/expense/getexpenses`
const getExpenses = (query: string): Promise => {
return axios
.get(`${GET_EXPENSES_URL}?${query}`)
.then((d: AxiosResponse) => d.data)
}
const getExpenseById = (id: ID): Promise => {
return axios
.get(`${GET_EXPENSE_URL}/${id}`)
.then((response: AxiosResponse>) => response.data)
.then((response: Response) => response.data)
}
const createExpense = (expense: Expense): Promise => {
return axios
.post(CREATE_EXPENSE_URL, expense)
.then((response: AxiosResponse>) => response.data)
.then((response: Response) => response.data)
}
const updateExpense = (expense: Expense): Promise => {
return axios
.put(`${UPDATE_EXPENSE_URL}/${expense.id}`, expense)
.then((response: AxiosResponse>) => response.data)
.then((response: Response) => response.data)
}
const deleteExpense = (expenseId: ID): Promise => {
return axios.delete(`${DELETE_EXPENSE_URL}/${expenseId}`).then(() => {})
}
const deleteSelectedExpenses = (expenseIds: Array): Promise => {
const requests = expenseIds.map((id) => axios.delete(`${DELETE_EXPENSE_URL}/${id}`))
return axios.all(requests).then(() => {})
}
export {getExpenses, deleteExpense, deleteSelectedExpenses, getExpenseById, createExpense, updateExpense}
```
```
// folder
--> expensetypes-list
```
```typescript
// file
// _requests.ts
import axios, {AxiosResponse} from 'axios'
import {ID, Response} from '../../../../../_metronic/helpers'
import {ExpenseType, ExpenseTypesQueryResponse} from './_models'
const API_URL = process.env.REACT_APP_API_URL
const GET_EXPENSETYPE_URL = `${API_URL}/expensetype/getexpensetype`
const CREATE_EXPENSETYPE_URL = `${API_URL}/expensetype/addexpensetype`
const UPDATE_EXPENSETYPE_URL = `${API_URL}/expensetype/updateexpensetype`
const DELETE_EXPENSETYPE_URL = `${API_URL}/expensetype/deleteexpensetype`
const GET_EXPENSETYPES_URL = `${API_URL}/expensetype/getexpensetypes`
const getExpenseTypes = (query: string): Promise => {
return axios
.get(`${GET_EXPENSETYPES_URL}?${query}`)
.then((d: AxiosResponse) => d.data)
}
const getExpenseTypeById = (id: ID): Promise => {
return axios
.get(`${GET_EXPENSETYPE_URL}/${id}`)
.then((response: AxiosResponse>) => response.data)
.then((response: Response) => response.data)
}
const createExpenseType = (expensetype: ExpenseType): Promise => {
return axios
.post(CREATE_EXPENSETYPE_URL, expensetype)
.then((response: AxiosResponse>) => response.data)
.then((response: Response) => response.data)
}
const updateExpenseType = (expensetype: ExpenseType): Promise => {
return axios
.put(`${UPDATE_EXPENSETYPE_URL}/${expensetype.id}`, expensetype)
.then((response: AxiosResponse>) => response.data)
.then((response: Response) => response.data)
}
const deleteExpenseType = (expensetypeId: ID): Promise => {
return axios.delete(`${DELETE_EXPENSETYPE_URL}/${expensetypeId}`).then(() => {})
}
const deleteSelectedExpenseTypes = (expensetypeIds: Array): Promise => {
const requests = expensetypeIds.map((id) => axios.delete(`${DELETE_EXPENSETYPE_URL}/${id}`))
return axios.all(requests).then(() => {})
}
export {getExpenseTypes, deleteExpenseType, deleteSelectedExpenseTypes, getExpenseTypeById, createExpenseType, updateExpenseType}
```
{% hint style="info" %}
***Good to know:*** *ziref is used for code files hold in a folder for each entity.*
{% endhint %}
# Zontroy AI Offline Code Generator Tutorial
# Zontroy Syntax
### *zg Prefix*
*In Zontroy language keywords starts with **zg** prefix. It allows Zontroy to distinguish code written in Java, Python, Go etc. and Zontroy Language.*
*For example, zg-entity is a predefined object of an entity corresponding to a table in database. Another example is zg-for that can execute a block of code a number of times.*
### *Triple Brackets*
*Brackets have to be written triple times in Zontroy. It is because while implementing a code file Zontroy code is written into the code of another programming language. It helps Zontroy to distinguish code written in Java, Python, Go etc. and Zontroy Language.*
***Parentheses ((( ))):** Used to group expressions.*
***Curly braces {{{ }}}:*** *Used to group statements together. They are used to define a code block and are used in control statements (if, for, etc) and classes, methods and other constructs.*
***Square brackets \[\[\[ ]]]:** Used to operate on pre-defined objects.*
### Triple Operators
*Operators and marks have to be written triple times or more in Zontroy. It is because while implementing a code file Zontroy code is written into the code of another programming language.*
*When we implement a for loop we will write triple left parantheses, triple right parantheses, triple left braces and triple right braces.*
***Equality =====:** Used to compare right side and left side expression. It is used as five equal signs.*
{% hint style="info" %}
***Good to know:*** *Zontroy IDE has its own hightlighter for Zontroy Language so code written in Zontroy is easy to read and maintain.*
{% endhint %}
# zg-entity
*zg-entity or zg-e*
*zg-entity is a predefined object to access to fields and properties of a table in the database. You need to write zg-entity with square brackets if you don't use it with a built-in function. In build-in functions it is used with parantheses.*
*zg-entity object can be used in zsif, zref and ziref file directly.*
### *Example Usage*
```
// access to name field of an entity
[[[zg-entity...zg-name]]]
// or
[[[zg-e...zg-name]]]
```
### *Example Usage as a Built-in Function Parameter*
```
// access to name field of an entity and singularize it using built-in function
zg-singularize(((zg-entity...zg-name)))
//or
zg-singularize(((zg-e...zg-name)))
```
### *Fields and Properties of zg-entity*
*Every field and property has a purpose in Zontroy to store spesific data for code generation.*
#### *zg-fields or zg-fs*
*zg-fields is a collection of fields in an entity like columns in a table. You need to iterate zg-fields using zg-for loop to access the properties of each field.*
```
[[[zg-entity...zg-fields]]]
//or
[[[zg-entity...zg-fs]]]
// example usage
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-name]]] }}}
```
***zg-field or zg-f***
*zg-field or zg-f is* each one *from a collection of fields in an entity like columns in a table.*
```
//usage
[[[zg-entity...zg-field]]]
// or
[[[zg-entity...zg-f]]]
```
***zg-pkField" or zg-pk***
*Returns the field, which is the primary key of any entity in the database.*
```
// usage
[[[zg-entity...zg-pkField...zg-name]]]
// or
[[[zg-entity...zg-pk...zg-name]]]
```
#### *zg-pkFields or zg-pks*
*This is a collection of primary key fields in a table. This property supports multiple primary keys. While iterating list of primary keys you can access the properties of each primary key field.*
```
[[[zg-entity...zg-pkFields]]]
//or
[[[zg-entity...zg-pks]]]
```
***zg-nonPKFields or zg-npks***
It is responsible for fetching fields from within the entity that do not have primary keys.
```
//usage
[[[zg-entity...zg-nonPKFields]]]
//or
[[[zg-entity...zg-npks]]]
// for example
zg-for(((zg-item:::[[[zg-entity...zg-nonPKFields]]]))){{{
[[[zg-item...zg-name]]]
}}}
```
***zg-nonKeyFields or zg-nkfs***
It is responsible for fetching fields that do not have primary keys and foreign keys from within the entity.
```
//usage
zg-for(((zg-item:::[[[zg-entity...zg-nonKeyFields]]]))){{{
[[[zg-item...zg-name]]]
}}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-nkfs]]]))){{{
[[[zg-item...zg-name]]]
}}}
```
***zg-fkFields or zg-fks***
Returns fields with foreign keys in the entity.
```
//usage
zg-for(((zg-item:::[[[zg-entity...zg-fkFields]]]))){{{
[[[zg-item...zg-name]]]
}}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fks]]]))){{{
[[[zg-item...zg-name]]]
}}}
```
***zg-nonFKFields or zg-nfks***
Returns fields in the entity that do not contain foreign keys.
```
//usage
zg-for(((zg-item:::[[[zg-entity...zg-nonFKFields]]]))){{{
[[[zg-item...zg-name]]]
}}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-nfks]]]))){{{
[[[zg-item...zg-name]]]
}}}
```
#### *zg-referencingFields or zg-ref*
*List of referencing fields of an entity is accesible by zg-referencingFields. It also means that zg-referencingFields is a collection of foreign keys in a table.*
```
[[[zg-entity...zg-referencingFields]]]
//or
[[[zg-entity...zg-ref]]]
```
#### *zg-referencedFields or zg-refs*
*zg-referencingFields is an object for the list of referenced fields of an entity by another entity. It also means that zg-referencedFields is a collection of columns in a table referenced by another table in the database.*
```
[[[zg-entity...zg-referencedFields]]]
//or
[[[zg-entity...zg-refs]]]
```
***zg-dataType or zg-dt***
*Returns the data type of any field in the entity.*
//usage
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-dataType]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-dt]]] }}}
***zg-targetType or zg-tt***
*It refers to the equivalent of the datatype of a field in an entity in the database in any programming language.*
```
//usage
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-targetType]]] }}}
// for mysql and go
// datatype of zg-item is bigint, targettype of zg-item is bigint->int64 | so it is int64
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-tt]]] }}}
```
***zg-nullTargetType or zg-ntt***
Returns the null target type value in any programming language of the data type of a field in an entity in the database.
```
//usage
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-nullTargetType]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-ntt]]] }}}
```
***zg-primitiveType or zg-pt***
Returns the primitive type value in any programming language of the data type of a field in an entity in the database.
```
//usage
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-primitiveType]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-pt]]] }}}
```
***zg-default or zg-def***
*Returns the default value of any field in the entity*
```
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-default]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-def]]] }}}
```
***zg-required or zg-r***
It is used to express that the value of the field in the entity cannot be empty.
```
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-required]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-r]]] }}}
```
***zg-maxLength or zg-ml***
It is used to get the maximum length of the value of the field in the entity.
```
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-maxLength]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-ml]]] }}}
```
***zg-NumericPrecision or zg-np***
Precision is the number of digits in a number and finds the precision of the number of digits before the decimal point.
```
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-NumericPrecision]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-np]]] }}}
```
***zg-NumericScale or zg-ns***
Scale is the number of digits to the right of the decimal point in a number and deals with the precision of the number of digits after the decimal point.
```
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-NumericScale]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-ns]]] }}}
```
***zg-DatetimePrecision or zg-dp***
Indicates how precisely date and time data is recorded. This means that data containing date and time information can be stored in detail down to subunits such as seconds, milliseconds, microseconds.
```
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-DatetimePrecision]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-dp]]] }}}
```
***zg-referencedEntity or zg-re***
"zg-referencedEntity" is a term that usually refers to another entity in a system or data model. In relational databases, this refers to the connection of a particular entity to another entity. So Returns the entity that is a reference to the entity.
```
[[[zg-entity...zg-referencedEntity]]]
// or
[[[zg-entity...zg-re]]]
```
***zg-referencedEntityName or zg-ren***
Returns the entity name that is a reference to the entity.
```
[[[zg-entity...zg-referencedEntityName]]]
// or
[[[zg-entity...zg-ren]]]
```
***zg-referencedFieldName or zg-rfn***
Returns the field name that is a reference to the field in entity.
```
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-referencedFieldName]]] }}}
// or
zg-for(((zg-item:::[[[zg-entity...zg-fields]]]))){{{
[[[zg-item...zg-rfn]]] }}}
```
***zg-generateBlock***
Generate block If we only want code generation in one block of the code file, we add generate block to that section.
```
zg-generateBlock((([[[zg-entity...zg-pkField...zg-name]]])))
```
***zg-protectBlock***
Protect block ensures that the code is not crushed during code generation if we want a part of the existing code to be protected and not changed.
```
zg-protectBlock((([[[zg-entity...zg-pkField...zg-name]]])))
```
#### *zg-schema*
*It means the name of schema in the database.*
```
[[[zg-entity...zg-schema]]]
```
#### *zg-name or zg-n*
*It means the name of entity in the database.*
```
[[[zg-entity...zg-name]]]
//or
[[[zg-entity...zg-n]]]
```
#### *zg-targetName or zg-tn*
*It means the name of entity given by developer in Zontroy Properties Window.*
```
[[[zg-entity...zg-targetName]]]
//or
[[[zg-entity...zg-tn]]]
```
#### *zg-alternativeName or zg-an*
*It means the alternative name of entity given by developer in Zontroy Properties Window.*
```
[[[zg-entity...zg-alternativeName]]]
//or
[[[zg-entity...zg-an]]]
```
#### *zg-label*
*It means the label of entity given by developer in Zontroy Properties Window.*
```
[[[zg-entity...zg-label]]]
```
#### *zg-rowOrder or zg-ro*
*It means the order of entity given by developer in Zontroy Properties Window. Zontroy sorts entities by value of row order property automatically.*
```
[[[zg-entity...zg-rowOrder]]]
//or
[[[zg-entity...zg-ro]]]
```
#### *zg-description or zg-d*
*It means the description of entity given by developer in Zontroy Properties Window.*
```
[[[zg-entity...zg-description]]]
//or
[[[zg-entity...zg-d]]]
```
#### *zg-displayFields or zg-dfs*
*zg-displayFields is a collection of fields enterd by developer in Zontroy Properties Window and it is a group of field to use further.*
```
[[[zg-entity...zg-displayFields]]]
//or
[[[zg-entity...zg-dfs]]]
```
#### zg-extra1 or zg-e1
*zg-extra1 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra1]]]
//or
[[[zg-entity...zg-e1]]]
```
#### *zg-extra2 or zg-e2*
*zg-extra2 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra2]]]
//or
[[[zg-entity...zg-e2]]]
```
#### *zg-extra3 or zg-e3*
*zg-extra3 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra3]]]
//or
[[[zg-entity...zg-e3]]]
```
#### *zg-extra4 or zg-e4*
*zg-extra4 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra4]]]
//or
[[[zg-entity...zg-e4]]]
```
#### zg-extra5 or zg-e5
z*g-extra5 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra5]]]
//or
[[[zg-entity...zg-e5]]]
```
#### *zg-extra6 or zg-e6*
*zg-extra6 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra6]]]
//or
[[[zg-entity...zg-e6]]]
```
#### *zg-extra7 or zg-e7*
*zg-extra7 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra7]]]
//or
[[[zg-entity...zg-e7]]]
```
#### *zg-extra8 or zg-e8*
*zg-extra8 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra8]]]
//or
[[[zg-entity...zg-e8]]]
```
#### *zg-extra9 or zg-e9*
*zg-extra9 is a reserved property to be given by developer for personal purpose in Zontroy Properties Window.*
```
[[[zg-entity...zg-extra9]]]
//or
[[[zg-entity...zg-e9]]]
```
# zg-entities
***zg-entities or zg-es***
.zsif file example
*zg-entities is used to retrieve all tables in a database. The zg-entities object can usually be run for .zsif files and can be used in a zg-for loop to perform a variety of operations, such as finding tables in a database.*
```
// To access the name of each table in entities
zg-for(((zg-item:::[[[zg-entities]]]))){{{
[[[zg-item...zg-name]]] }}}
// or
zg-for(((zg-item:::[[[zg-es]]]))){{{
[[[zg-item...zg-name]]] }}}
```
# zg-if
### If Statement:
*if statement is a programming conditional statement that, if proved true, performs a function or displays information. Below is a general example of an if statement, specific to Zontroy Language.*
```
zg-if((([[[variable1]]]=====[[[variable2]]]))){{{
//Variables are equal.
}}}
```
### Else If Statement:
*elseif, as its name suggests, is formed by combining if and else statements. Like else, it is used to execute a different statement in case the original if statement returns false. However, unlike else, it will only execute the relevant statement if its conditional expression returns true.*
```
zg-elseif((([[[variable1]]]=====[[[variable2]]]))){{{
//Variables are equal.
}}}
//or
zg-eif((([[[variable1]]]=====[[[variable2]]]))){{{
//Variables are equal.
}}}
//or
zg-elif((([[[variable1]]]=====[[[variable2]]]))){{{
//Variables are equal.
}}}
//or
zg-elsif((([[[variable1]]]=====[[[variable2]]]))){{{
//Variables are equal.
}}}
```
### Else Statement:
*If we want to run a different code block when the condition is not met, we use else.*
```
zg-else{{{
// if the condition is not met
}}}
```
# zg-for
### *For Loop*
*For loop is a programming language conditional iterative statement which is used to check for certain conditions and then repeatedly execute a block of code as long as those conditions are met.*
```
zg-for((([[[variable]]]:::[[[predefined_collection]]]))){{{
}}}
```
# Data Type Conversion
## *Type Conversion*
*Data Type Conversion between data source and programming language is automatically done by Zontroy Generator. You can customize conversion by using Data Type Conversion tool window. In the Data Type Conversion table, there are null target type and primitive type data types according to any programming language for each target data type in the database. Data Type Conversion process has generally become necessary for the data types of any database to work in harmony with each other with Zontroy.*
# Built-in Functions
## Functions
*Zontroy interpreter has a number of functions and types built into it that are always available. Every function performs a single task.*
### String Functions
*String functions allow developers to perform certain operations on strings in Zontroy.*
***zg-toStr((()))** : Returns a string representing the object.*
***zg-upper((())) or zg-u((()))** : Converts string to upper case.*
***zg-lower((())) or zg-l((()))** : Converts string to lower case.*
***zg-upperFirstCase((())) or zg-ufc((()))** : Converts first character of a string to upper case.*
***zg-lowerFirstCase((())) or zg-lfc((()))** : Converts first character of a string to lower case.*
***zg-pluralize((())) or zg-p((()))** : Pluralize a name if it is in a single form.*
***zg-singularize((())) or zg-s((()))** : Singularize a name if it is in a plural form.*
**zg-puts((())) :** *Prints all characters in the character array indicated by the str parameter to the screen.*
***zg-notLast((()))***** :** *The not-last builtin function, which is generally used in the for loop, is used to ensure that the desired character does not appear at the end of the loop.*
***zg-notFirst((())) :*** *The not-first built-in function, usually used in the for loop, is used to ensure that the desired character does not appear only at the beginning of the loop.*
***zg--tripleDots((())) :** Allows adding **...** to any word or sentence.*
***zg-tripleLeftParenthesis((())) or zg-tripleLeftParentheses((())***) ***or zg-tripleLeftRoundBrackets((()))*** : *It puts three left parenthesis ((( in the desired location.*
***zg-tripleRightParenthesis((())) or zg-tripleRightParentheses((())) or zg-tripleRightRoundBrackets((())) :** It puts three right parenthesis ))) in the desired location.*
***zg-tripleLeftSquareBrackets((())) :** It puts three left square brackets \[\[\[ in the desired location.*
***zg-tripleRightSquareBrackets((())) :*** I*t puts three right square brackets ]]] in the desired location.*
***zg-tripleLeftCurlyBrackets((())) :** It puts three left curly brackets {{{ in the desired location.*
***zg-tripleRightCurlyBrackets((())) :** It puts three right curly brackets }}} in the desired location.*
***zg-tripleLeftAngleBrackets((())) or zg-tripleLessThan((())) :** It puts three left angle brackets <<< in the desired location*.
***zg-tripleRightAngleBrackets((())) or zg-tripleGreaterThan((())) :** It puts three right angle brackets >>> in the desired location.*
***zg-zero((())) :** returns the value zero.*
***zg-estimateDisplayField((())) :** It takes zg-entity as a parameter and finds the area of the entity to be displayed on the screen.*
### Type Conversion Functions
Data Type Converter
*Zontroy applies data type conversions from database type to variable type automatically. However if there is additional conversion need built-in functions are available. Type conversion functions provides additional functionality to convert data type of a column in the database of current project.*
***zg-convertToCSharpDataType** converts data type of an entity to C# data type.*
***zg-convertToGoDataType** converts data type of an entity to Go data type.*
***zg-convertToJavaDataType** converts data type of an entity to Java data type.*
***zg-convertToJavascriptDataType** converts data type of an entity to Javascript data type.*
***zg-convertToPHPDataType** converts data type of an entity to PHP data type.*
***zg-convertToPythonDataType** converts data type of an entity to Python data type.*
***zg-convertToRDataType** converts data type of an entity to R data type.*
***zg-convertToSwiftDataType** converts data type of an entity to Swift data type.*
***zg-convertToTypeScriptDataType** converts data type of an entity to TypeScript data type.*
***zg-convertToVBNetDataType** converts data type of an entity to VB.Net data type.*
***zg-convertToOtherDataType** converts data type of an entity to Other Language data type defined by developer.*
***zg-convertToAnotherDataType** converts data type of an entity to Another Language data type defined by developer.*
# Supported AI Models
Zontroy AI supports integration with numerous leading AI platforms, each offering\
unique models with distinct capabilities and specializations. By providing this broad spectrum of AI models, Zontroy ensures that developers can always access the most suitable AI capabilities for their specific needs.\
The following AI providers and their respective models are currently supported within the Zontroy AI ecosystem:
| AI Provider or Gateway | Supported AI Model |
| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| OpenAI |
gpt-4.5-preview
gpt-4o
gpt-4-turbo
gpt-4
gpt-3.5-turbo
|
| Qwen |
qwen-max
qwen-plus
qwen-turbo
|
| DeepSeek |
deepseek-reasoner
deepseek-chat
|
| xAI | grok-2-latest |
| Anthropic |
claude-3-7-sonnet-20250219
claude-3-5-sonnet-20241022
claude-3-5-haiku-20241022
claude-3-opus-20240229
claude-3-haiku-20240307
|
| Google |
gemini-2.0-flash-exp
gemini-1.5-flash
gemini-1.5-flash-8b
gemini-1.5-pro
|
| Llama |
llama3.3-70b
llama3.2-3b
llama3.1-405b
llama3.1-70b
llama3.1-8b
llama3-8b
|
| OpenRouter |
qwen/qwen2.5-vl-32b-instruct:free
deepseek/deepseek-chat-v3-0324:free
|
# OpenAI
OpenAI's models are renowned for their versatility, strong reasoning capabilities, and excellent code generation across multiple programming languages.\
**Supported Models:** - **GPT-4.5-preview:** OpenAI's most advanced model, offering state- of-the-art performance in code generation, problem-solving, and natural language understanding. - **GPT-4o:** A multimodal model optimized for both code and natural language tasks, with enhanced reasoning capabilities. - **GPT-4-turbo:** A faster version of GPT-4 that maintains high-quality outputs while providing improved response times. - **GPT-4:** A powerful model with strong reasoning and code generation capabilities across numerous programming languages. - **GPT-3.5-turbo:** A more efficient model that\
balances performance with speed, suitable for less complex development tasks.\
**Strengths:** - Excellent general-purpose coding assistance - Strong reasoning and\
problem-solving capabilities - Broad knowledge across programming languages and frameworks - High-quality documentation generation - Effective architectural planning and system design
# Anthropic (Claude)
Claude models from Anthropic are characterized by their nuanced understanding of context, strong reasoning capabilities, and ability to handle longer inputs and generate detailed explanations.\
**Supported Models:** - **Claude-3-7-sonnet-20250219:** A balanced model offering strong performance across a wide range of tasks with excellent context handling. - **Claude-3-5- sonnet-20241022:** An enhanced version of the Sonnet model with improved reasoning capabilities. - **Claude-3-5-haiku-20241022:** A faster, more efficient model suitable for quick interactions and simpler tasks. - **Claude-3-opus-20240229:** Anthropic's most powerful model, excelling at complex reasoning and detailed analysis. - **Claude-3- haiku-20240307:** A lightweight model optimized for efficiency while maintaining good quality outputs.\
**Strengths:** - Exceptional context understanding and retention - Detailed, well-structured explanations of complex concepts - Strong performance with architectural planning and system design - Excellent documentation generation with clear, comprehensive explanations - Nuanced understanding of requirements and constraints.
# DeepSeek
DeepSeek models specialize in deep reasoning and algorithmic problem-solving,\
making them particularly valuable for complex computational challenges.\
**Supported Models:** - **DeepSeek-reasoner:** A model specifically designed for complex reasoning tasks and algorithmic problem-solving. - **DeepSeek-chat:** A versatile model balancing reasoning capabilities with general coding assistance.\
**Strengths:** - Superior performance on algorithmic challenges and optimization\
problems - Strong mathematical reasoning and computational thinking - Excellent for data structure implementation and algorithm design - Precise and efficient code generation for performance-critical components - Detailed explanations of complex algorithms and computational approaches.
# Google (Gemini)
Google's Gemini models offer strong performance across a wide range of development tasks, with particular strengths in web development and Google-related technologies.\
**Supported Models:** - **Gemini-2.0-flash-exp:** An experimental high-performance model with enhanced capabilities. - **Gemini-1.5-flash:** A balanced model offering good performance with faster response times. - **Gemini-1.5-flash-8b:** A more compact model optimized for efficiency. - **Gemini-1.5-pro:** Google's most capable model, offering advanced reasoning and code generation.\
**Strengths:** - Excellent knowledge of Google technologies and platforms - Strong web development capabilities, particularly for JavaScript and TypeScript - Good\
understanding of cloud architectures and services - Effective for mobile development, especially Android - Comprehensive knowledge of modern web frameworks and libraries.
# Qwen
Qwen models excel at handling multilingual development scenarios and offer strong performance across a variety of programming tasks.\
**Supported Models:** - **Qwen-max:** The most powerful Qwen model, offering advanced capabilities across multiple domains. - **Qwen-plus:** A balanced model providing strong performance for most development tasks. - **Qwen-turbo:** An efficiency-focused model that prioritizes speed while maintaining good quality.\
**Strengths:** - Excellent multilingual support, particularly for Asian languages - Strong performance with cross-cultural development requirements - Good understanding of international compliance and localization needs - Effective code generation across multiple programming paradigms - Balanced performance across various development domains.
# xAI
xAI's Grok model offers innovative approaches to problem-solving and creative code generation.\
**Supported Models:** - **Grok-2-latest:** xAI's advanced model combining strong reasoning with creative problem-solving approaches.\
**Strengths:** - Creative approaches to development challenges - Strong reasoning\
capabilities for novel problem domains - Effective at generating innovative solutions to complex problems - Good performance with emerging technologies and frameworks - Balanced capabilities across multiple programming languages
# Llama
Llama models provide strong open-source alternatives with particular strengths in\
systems programming and performance optimization.\
**Supported Models:** - **Llama3.3-70b:** A large, powerful model with comprehensive\
capabilities across multiple domains. - **Llama3.2-3b:** A compact, efficient model suitable for simpler tasks and quick interactions. - **Llama3.1-405b:** An extremely large model offering state-of-the-art performance for complex tasks. - **Llama3.1-70b:** A balanced model providing strong performance across most development scenarios. - **Llama3.1-8b:** A more efficient model that balances performance with resource utilization. - **Llama3-8b:** A compact model focused on efficiency while maintaining good output quality.\
**Strengths:** - Excellent performance for systems programming languages like C, C++, and Rust - Strong capabilities for performance optimization and low-level programming - Good understanding of memory management and resource utilization - Effective for embedded systems and IoT development - Balanced performance across multiple programming paradigms.
# OpenRouter
OpenRouter provides access to additional models through a unified gateway, expanding the range of specialized AI capabilities available within Zontroy AI.\
**Supported Models:** - **Qwen/qwen2.5-vl-32b-instruct**:free: A visual-language model\
from Qwen with multimodal capabilities. - **DeepSeek/deepseek-chat-v3-0324**:free: An enhanced version of DeepSeek's chat model with improved performance.\
**Strengths:** - Access to specialized models not directly available through other providers Multimodal capabilities for development tasks involving visual elements - Additional options for specific development scenarios - Alternative implementations of popular model architectures - Expanded range of specialized capabilities.
# Selecting the Optimal Model for Different Tasks
Different development tasks benefit from different AI models based on their specific strengths and specializations. Here are recommendations for selecting the most appropriate models for various common development scenarios:\
***Web Development***\
For frontend and web development tasks, consider: - **OpenAI's GPT-4o** or **GPT-4.5**-preview: Excellent for React, Angular, and Vue development with strong understanding of modern web practices. - Google's **Gemini-1.5-pro:** Particularly strong with JavaScript, TypeScript, and Google-related web technologies. - **Claude-3-opus:** Excellent for explaining complex web concepts and architectural planning.\
***Backend Development***\
For server-side and API development, consider: - **OpenAI's GPT-4.5-preview:** Strong across multiple backend languages and frameworks. - **DeepSeek-reasoner:** Excellent for performance-critical backend components and algorithms. - **Llama3.1-70b:** Good performance for systems programming aspects of backend development.\
***Mobile Development***\
For iOS, Android, and cross-platform mobile development: - **Google's Gemini models:** Particularly strong for Android development. - **OpenAI's GPT-4o:** Excellent for Swift and iOS development. - **Claude-3-7-sonnet:** Good for explaining platform-specific concepts and best practices.\
***Data Science and Machine Learning***\
For AI, ML, and data science tasks: - **DeepSeek-reasoner:** Excellent for algorithm\
implementation and optimization. - **OpenAI's GPT-4.5-preview:** Strong across the full data science stack. - **Claude-3-opus:** Particularly good at explaining complex ML concepts and approaches.\
***DevOps and Infrastructure***\
For infrastructure, deployment, and operations tasks: - **Llama3.1-70b** or **Llama3.3-70b:** Strong with systems-level concepts and tooling. - **OpenAI's GPT-4-turbo:** Good balance of knowledge across various cloud platforms. - **Claude models:** Excellent for explaining complex infrastructure concepts and best practices.\
***Database and Data Modeling***\
For database design, queries, and data modeling: - **DeepSeek-reasoner:** Strong with complex query optimization and data structures. - **OpenAI's GPT-4.5-preview:** Excellent across multiple database technologies. - **Claude-3-opus:** Particularly good at explaining data modeling concepts and approaches.\
**Configuring API Keys for Model Access**\
To access the various AI models supported by Zontroy AI, you'll need to configure API keys for the respective providers. This process ensures secure access to external AI services while maintaining your privacy and control.\
***Obtaining API Keys***\
For each AI provider, you'll need to obtain an API key through the following general\
process:\
1\. Create or log into your account on the respective AI platform's website.\
2\. Navigate to the API or developer section of the platform.\
3\. Generate a new API key, noting any usage limits or pricing tiers.\
4\. Copy the generated API key for use in Zontroy AI.
# Javascript
## Introduction
JavaScript development presents unique challenges in today's complex web ecosystem. From managing frontend frameworks to building scalable backend services, JavaScript developers face an ever-expanding set of tools, libraries, and best practices. Zontroy AI transforms JavaScript development by seamlessly integrating the strongest capabilities from today's leading AI systems—Claude, ChatGPT, Gemini, Llama, Deep Seek, Qwen, and xAI—into a unified platform that responds intelligently to your JavaScript needs.\
This manual provides JavaScript developers with essential guidance for leveraging\
Zontroy AI's features through effective prompting to enhance productivity, improve code quality, and streamline development workflows. Unlike traditional tools that require specific configuration, Zontroy AI works through natural language prompts, allowing you to describe your JavaScript tasks and receive tailored assistance.
### JavaScript-Specific Advantages of Zontroy AI
Zontroy AI offers several distinct advantages for JavaScript developers:\
**•Framework-Aware Code Generation:** Request and receive idiomatic code for\
React, Angular, Vue, Express, and other popular JavaScript frameworks\
**•Full-Stack JavaScript Support:** Get assistance across the entire JavaScript stack, from frontend UI components to backend Node.js services\
**•Modern JavaScript Features:** Leverage the latest ECMAScript features and\
patterns in your code\
**•Testing and Debugging Assistance:** Generate unit tests and receive help\
diagnosing complex JavaScript bugs\
**•Performance Optimization:** Get recommendations for improving JavaScript\
performance in browsers and Node.js\
This manual focuses specifically on how to craft effective prompts for JavaScript\
workflows, providing concise guidance for maximizing your productivity with Zontroy AI's suite of features.
### Getting Started with Prompt-Driven JavaScript Development
#### Understanding How Prompts Work for JavaScript
Zontroy AI responds to natural language prompts about JavaScript development tasks. The quality and specificity of your prompts directly impact the assistance you receive.\
For JavaScript development:\
1\. Describe your JavaScript task or question in natural language\
2\. Include relevant context about your JavaScript project\
3\. Specify any framework, runtime, or browser requirements\
4\. Receive tailored JavaScript code, explanations, or guidance
### Crafting Effective JavaScript Prompts
To get the best JavaScript assistance, include these elements in your prompts:\
**•Environment Information:** Specify browser, Node.js, or other runtime\
environments\
Example: "I need a Node.js script that processes CSV files and uploads them to S3"\
**•Framework Context:** Mention any frameworks or libraries you're using\
Example: "In my React application using Redux, I need a component that..."\
**•JavaScript Version:** Note if you're using specific ECMAScript features\
Example: "Using ES2022 features, write a function that..."\
**•Project Purpose:** Briefly explain what your code needs to accomplish\
Example: "I'm building a dashboard that visualizes real-time data from an API"
### Providing Context for JavaScript Projects
When working with existing JavaScript projects, provide context in your prompts:\
**•Project Structure:** Briefly describe your JavaScript project organization\
**•Dependencies:** Mention key libraries and frameworks in use\
**•Coding Standards:** Note any style guides or patterns you follow\
**•Browser Support:** Specify browser compatibility requirements\
Example context-setting prompt:\ I'm working on a React 18 project with Redux for state management and Jest for testing. We follow the Airbnb JavaScript style guide. I need help creating a custom hook that...
#### Framework and Environment Considerations
Different JavaScript environments require different approaches. Specify:\
**•Frontend Development:** Mention browser targets, DOM interactions, or mobile\
considerations\
**•Backend Development:** Specify Node.js version, database integrations, or API\
patterns\
**•Full-Stack Development:** Explain how frontend and backend components interact\
Example:\ I'm building a full-stack JavaScript application with a React frontend and Express backend. I need help implementing JWT authentication that works across both environments.
### Core Features for JavaScript Development
#### Chat Feature for JavaScript
The Chat feature provides interactive assistance for JavaScript development through natural language prompts.
#### JavaScript-Specific Prompting Techniques
For optimal JavaScript assistance, structure your prompts with:\
**•Task Description:** Clearly state what you need to accomplish\
**•Code Context:** Share relevant existing code when applicable\
**•Expected Behavior:** Describe how the code should function\
**•Edge Cases:** Mention any special conditions to handle\
Example prompts:\ "Create a JavaScript function that sorts an array of objects by\ multiple properties, with support for ascending and descending\ order"\ "Help me debug this Promise chain that's not catching errors\ properly: \[paste code]"\ "Write a React component that implements infinite scrolling for\ a list of products"
#### Modern JavaScript Features
Request assistance with modern JavaScript features:\ "Show me how to use the optional chaining and nullish coalescing\ operators to simplify this code: \[paste code]"\ "Convert this callback-based function to use async/await: \[paste\ code]"\ "Explain how to use JavaScript modules with dynamic imports for\ code splitting"
#### JavaScript Debugging Assistance
When facing JavaScript bugs:\ "I'm getting 'Uncaught TypeError: Cannot read property 'value'\ of undefined' in this function. How can I fix it? \[paste code]"\ "My event listeners are causing a memory leak. How can I\ properly clean them up?"\ "This async function sometimes returns before the data is ready.\ What's wrong with my code? \[paste code]"
#### Collaborator Feature for JavaScript
The Collaborator feature generates complete JavaScript files based on your\
specifications.
#### Requesting JavaScript File Generation
To get complete JavaScript files:\
"Create a JavaScript utility file with functions for date formatting, validation, and manipulation that works in both browser and Node.js environments"\ "Generate a complete React component for a dashboard that displays user statistics with charts and filters"\ "Write an Express.js router module for user authentication with registration, login, and password reset endpoints"
#### Framework-Specific JavaScript Generation
Request code for specific frameworks:\ "Create a Vue.js component that implements a multi-step form with validation and state persistence"\ "Generate a React custom hook that manages pagination state and data fetching with error handling"\ "Write an Angular service that handles offline data synchronization with IndexedDB"
#### JavaScript Module and Component Generation
For modular JavaScript code:\ "Create an ES module for handling form validation with support for different validation rules and error messages"\ "Generate a reusable JavaScript class for managing WebSocket connections with reconnection logic and event handling"\ "Write a Node.js module for processing and transforming CSV data with stream support for large files"
### Peerer Feature for JavaScript Projects
Peerer orchestrates multi-agent AI teams specialized for JavaScript development\
through your prompts.
#### Requesting Multi-Agent JavaScript Assistance
Use Peerer to assemble specialized teams:\ "I need a team to help me build a JavaScript e-commerce platform with:
* React frontend with shopping cart and checkout
* Node.js backend with payment processing
* MongoDB integration
* User authentication and authorization"
\
Complex JavaScript Architecture Assistance For large JavaScript projects, use Peerer to:\ "I need help designing a scalable architecture for a real-time collaborative editing application using JavaScript. Can you create :
1. Design the frontend state management
2. Plan the WebSocket communication
3. Structure the backend for horizontal scaling
4. Implement conflict resolution algorithms"
### Model Context Protocol (MCP) Tools for JavaScript
MCP Tools optimize interactions between different AI systems specifically for JavaScript workflows.
#### JavaScript Framework Integration
Request specialized assistance for frameworks:\ "Using MCP Tools, help me integrate a third-party payment gateway into my React application with proper error handling and loading states"\ "I need help setting up a Node.js microservices architecture with proper inter-service communication and error handling"
#### Full-Stack JavaScript Development
For full-stack projects:\ "Help me design a type-safe API contract between my Express backend and React frontend, including error handling and data validation"
### JavaScript-Specific Workflows
#### Modern JavaScript Syntax and Features
Request help with modern JavaScript features:\
**ES6+ Features**\ "Show me how to refactor this legacy JavaScript code to use modern ES6+ features like arrow functions, destructuring, and template literals"\ "Explain how to effectively use JavaScript Map and Set objects for better performance in this algorithm: \[paste code]"\
**Asynchronous JavaScript Patterns**\ "Help me understand the difference between Promises, async/ await, and generators in JavaScript with practical examples"\ "Refactor this callback-based API to use Promises and async/ await: \[paste code]"\
**Functional Programming in JavaScript**\ "Show me how to implement common functional programming patterns in JavaScript like map, filter, reduce, and compose"\ "Help me refactor this imperative code to use a more functional approach with immutability and pure functions"
### DOM Manipulation and Browser APIs
Request assistance with browser JavaScript:\ "Create a vanilla JavaScript carousel component without using any libraries, with touch support and accessibility features"\ "Show me how to use the Intersection Observer API to implement lazy loading of images in a web application"\ "Help me implement drag-and-drop functionality for a kanban board using the HTML5 Drag and Drop API"
#### JavaScript Testing and Debugging
Get help with testing and debugging:\ "Generate Jest tests for this JavaScript utility function, including edge cases and error scenarios: \[paste code]"\ "Show me how to use Chrome DevTools effectively to debug memory leaks in this JavaScript application"\ "Create a testing strategy for this React component, including unit tests, integration tests, and end-to-end tests"
### Framework Support
#### React Development
Request assistance with React:\ "Create a React component that implements a searchable, filterable data table with pagination and sorting"\ "Show me how to implement global state management in React using Context API and useReducer without external libraries"\ "Help me optimize the performance of this React component that's re-rendering too often: \[paste code]"
#### Angular Development
For Angular development:\ "Create an Angular service that handles authentication and authorization with route guards and HTTP interceptors"\ "Show me how to implement lazy loading of modules in an Angular application for better performance"\ "Help me understand how to effectively use RxJS operators in Angular services for data transformation and error handling"
#### Vue.js Development
For Vue.js projects:\ "Create a Vue.js component using the Composition API that implements a multi select dropdown with search functionality"\ "Show me how to implement Vuex store modules for a large-scale Vue application with proper namespacing"\ "Help me migrate this Vue 2 component to Vue 3 with the Composition API: \[paste code]"
#### Node.js and Express Development
For backend JavaScript:\ "Create an Express middleware for handling authentication with JWT tokens and role-based access control"\ "Show me how to implement a rate limiter in Node.js to protect API endpoints from abuse"\ "Help me design a scalable database schema and corresponding Mongoose models for a social media application"
### Conclusion
Zontroy AI transforms JavaScript development by providing intelligent, prompt-based assistance that understands JavaScript's unique challenges across frameworks and environments. By crafting effective prompts as outlined in this manual, you can leverage Zontroy AI to generate high-quality code, resolve complex issues, and accelerate your JavaScript development workflow.\
Whether you're building React applications, Angular components, or Node.js backends, Zontroy AI responds to your specific needs through natural language interaction, delivering precise, context-aware assistance without requiring complex configuration.
# Typescript
### Typescript Code Generator
*By Zontroy Team*
### Introduction
TypeScript development presents unique challenges and opportunities that Zontroy AI is perfectly positioned to address. As a statically typed superset of JavaScript, TypeScript offers enhanced code quality, better tooling, and improved developer experience—but it also introduces complexity in type definitions, interfaces, and compiler configurations.\
Zontroy AI transforms TypeScript development by seamlessly integrating the strongest capabilities from today's leading AI systems—Claude, ChatGPT, Gemini, Llama, DeepSeek, Qwen, and xAI—into a unified platform that responds intelligently to your TypeScript needs. This manual provides TypeScript developers with essential guidance for leveraging Zontroy AI's features through effective prompting to enhance productivity, improve code quality, and streamline development workflows.
### TypeScript-Specific Advantages of Zontroy AI
Zontroy AI offers several distinct advantages for TypeScript developers:\
**•Type-Aware Code Generation:** Request and receive properly typed TypeScript\
code with accurate interfaces, type definitions, and generics\
**•Type Error Resolution:** Quickly diagnose and resolve complex TypeScript compiler errors through natural language descriptions\
**•Framework-Specific TypeScript Support:** Get specialized assistance for Angular,\
React, NestJS, and other TypeScript-centric frameworks\
**•Declaration File Generation:** Request automated creation of .d.ts files for\
JavaScript libraries\
**•Migration Assistance:** Facilitate conversion from JavaScript to TypeScript with\
intelligent type inference\
This manual focuses specifically on how to craft effective prompts for TypeScript\
workflows, providing concise guidance for maximizing your productivity with Zontroy AI's suite of features.
### Getting Started with Zontroy AI for TypeScript
#### Understanding Prompt-Based TypeScript Assistance
Unlike tools that require specific configuration, Zontroy AI works through natural\
language prompts. For TypeScript development:\
1\. Describe your TypeScript task or question in natural language\
2\. Include relevant context about your TypeScript project\
3\. Specify any TypeScript-specific requirements (strictness level, framework, etc.)\
4\. Receive tailored TypeScript code, explanations, or guidance
#### Effective TypeScript Context Setting
When working with TypeScript projects, provide context in your prompts:\
**•Project Structure:** Briefly describe your TypeScript project organization\
**•TypeScript Version:** Mention which version you're using (e.g., "TypeScript 5.0")\
**•Compiler Options:** Note relevant tsconfig settings (e.g., "strict mode enabled")\
**•Framework Information:** Specify frameworks in use (e.g., "Angular 16 project")\
Example context-setting prompt:\ I'm working on a TypeScript 5.0 React project with strict null\ checks enabled.\ I need help creating a custom hook that...
#### Project Analysis Through Prompting
To get Zontroy AI to understand your TypeScript project better:\
1\. Share key TypeScript files and structures through prompts\
2\. Describe your type architecture and patterns\
3\. Explain framework usage and TypeScript integration points\
Example project analysis prompt:\ I have a TypeScript Angular project with the following\ structure:
* Core module with shared interfaces
* Feature modules with components
* State management using NgRx with typed actions
I need help understanding how to properly type my state\ selectors.
### Core Features for TypeScript Development
#### Chat Feature for TypeScript
The Chat feature provides interactive assistance for TypeScript development through natural language prompts.
#### TypeScript-Specific Prompting Techniques
For optimal TypeScript assistance, structure your prompts with:\
**•Type Information:** Mention relevant interfaces or types\
**•Compiler Options:** Note strict mode or other tsconfig settings\
**•Framework Context:** Specify Angular, React, or other frameworks\
Example prompts:\ "Create a TypeScript interface for a user profile with optional\ contact information and strict null checks"\ "Help me debug this TypeScript error: TS2339: Property 'id' does\ not exist on type 'User\[]'"\ "Generate a generic React component in TypeScript that accepts\ any data type with pagination"
#### Type System Assistance
Chat excels at helping with TypeScript's type system when you:\
**Describe Complex Types:** Ask for help with mapped types, conditional types, and\
type inference\
**Request Type Guards:** Ask for type predicates and narrowing functions\
**Explain Generic Needs:** Describe your requirements for generic type parameters\
and constraints\
Example:\ "I need to create a TypeScript utility type that makes all\ properties of an interface optional and nullable. Can you help\ me implement this?"
#### TypeScript Error Resolution
When encountering TypeScript errors:\
1\. Copy the error message and relevant code\
2\. Describe your tsconfig settings\
3\. Ask for explanations and suggested fixes\
Example:\ "I'm getting this TypeScript error: 'TS2322: Type 'string | undefined' is not assignable to type 'string'.'\
My code is: const name: string = user?.name;\
I have strict null checks enabled. How can I fix this?"
### Collaborator Feature for TypeScript
The Collaborator feature generates complete TypeScript files based on your\
specifications.
#### Requesting TypeScript File Generation
To get complete TypeScript files:\
1\. Describe the file's purpose and requirements\
2\. Specify TypeScript-specific needs (interfaces, types, generics)\
3\. Mention framework context if applicable\
4\. Include desired type strictness level\
Example request:\ "Create a TypeScript service for an Angular application that handles authentication with JWT tokens. Include proper interfaces for user data and API responses, error handling with custom types, and strict null checks."
#### Type Definition Generation
Request .d.ts declaration files by:\
1\. Providing the JavaScript code or library documentation\
2\. Specifying the module pattern (CommonJS, ES Modules, etc.)\
3\. Indicating required export style (default exports, named exports)\
Example:\ "Generate a TypeScript declaration file (.d.ts) for this JavaScript utility library that uses CommonJS modules. The library exports functions for date formatting and validation."
#### Interface and Type Creation
For complex data structures:\
1\. Describe the data model in natural language or provide sample JSON\
2\. Specify relationships between types\
3\. Indicate optional properties and nullable fields\
Example:\ "Create TypeScript interfaces for an e-commerce system with\ these entities:
* Product (id, name, price, category, optional description)
* Order (id, customer, products, quantities, status)
* Customer (id, name, email, optional shipping addresses)
Products belong to categories, orders contain multiple products with quantities, and customers can have multiple addresses."
#### Peerer Feature for TypeScript Projects
Peerer orchestrates multi-agent AI teams specialized for TypeScript development\
through your prompts.\
**Requesting Multi-Agent TypeScript Assistance**\
With using Peerer to assemble specialized teams:\ "build a TypeScript GraphQL API with:
* Type-safe schema definitions
* Resolver implementations
* Authentication middleware
* Integration with a PostgreSQL database using TypeORM"
#### Complex TypeScript Project Workflows
For large TypeScript projects, use Peerer to:\ "I need help refactoring a large TypeScript codebase from JavaScript classes to a more functional approach.\ Can you create:
1. Analyze my current class structure
2. Propose a functional architecture with proper typing
3. Create migration steps
4. Provide examples of refactored components"
### Model Context Protocol (MCP) Tools for TypeScript
MCP Tools optimize interactions between different AI systems specifically for TypeScript workflows.
#### TypeScript Framework Integration
Request specialized assistance for frameworks:\ "Using MCP Tools, help me create a properly typed Angular service that integrates with my REST API. The service should handle authentication, request/response\ typing, and error handling."\ "I need help setting up a React project with TypeScript, Redux Toolkit, and proper type safety between my store and components."
#### Type-Safe API Development
For API development:\ "Help me design a type-safe Express API with TypeScript that:
* Validates requests using zod
* Returns properly typed responses
* Handles errors with custom error types
* Includes middleware for authentication"
Emphasize privacy and performance needs:\ "Using the Offline Code Generator, create TypeScript utility types for working with deeply nested JSON structures. I need these to run locally for processing sensitive data."
#### TypeScript-Specific Capabilities
Request specialized TypeScript constructs:\ "Generate advanced TypeScript utility types for my project that can:
* Create deeply partial versions of interfaces
* Extract union types from tuples
* Infer return types from function signatures"
#### TypeScript-Specific Workflows
#### Advanced Type Manipulation
Request help with advanced TypeScript type features:\
**Mapped and Conditional Types**\ "Show me how to create a TypeScript mapped type that transforms all properties of an interface to be functions that return the original type."\ "Help me understand conditional types in TypeScript with examples of distributive conditional types and the infer keyword."\
**Generic Type Assistance**\ "I need to create a generic repository pattern in TypeScript that works with any entity type but enforces that entities have an ID property."
#### Type Definition Management
Streamline working with type definitions:\
**Declaration File Creation**\ "Help me create a declaration file for this third-party JavaScript library that I'm using in my TypeScript project. Here's the library's documentation and example usage..."\
**Module Augmentation**\ "Show me how to extend the Express Request interface to include a custom 'user' property with TypeScript's module augmentation."\
**JavaScript to TypeScript Migration**\
Request assistance with migration:\ "I have a JavaScript React component that I need to convert to TypeScript. Help me add proper typing while maintaining all functionality."\ "Provide a step-by-step guide for migrating my JavaScript Node.js application to TypeScript, including setting up tsconfig, adding types incrementally, and handling third-party libraries."
#### **Framework Support**
**Angular Development**\
Request TypeScript assistance for Angular:\ "Create an Angular component in TypeScript that displays a paginated list of products with filtering. Include proper interfaces for the product data and pagination state."\ "Help me implement type-safe form validation in Angular using reactive forms and custom validators."\
**React with TypeScript**\
For React development:\ "Create a custom hook in TypeScript for managing form state in React, with proper typing for form values, errors, and validation."\ "Show me how to properly type React context with TypeScript to ensure type safety when consuming context values."\
**NestJS Development**\
For backend TypeScript development with NestJS:\ "Generate a NestJS controller and service for user management with proper DTO classes, TypeORM entity definitions, and dependency injection."\ "Help me implement a custom decorator in NestJS that extracts and validates a JWT token from request headers."\
**Other TypeScript Frameworks**\
Request support for additional TypeScript frameworks:\ "Create a type-safe Express middleware for handling file uploads with proper TypeScript interfaces and error handling."\ "Show me how to set up a Vue 3 component using the Composition API with TypeScript, including props validation and emitted events typing."
### Conclusion
Zontroy AI transforms TypeScript development by providing intelligent, prompt based assistance that understands TypeScript's unique challenges. By crafting effective prompts as outlined in this manual, you can leverage Zontroy AI to generate type-safe code, resolve complex type issues, and accelerate your TypeScript development workflow.\
Whether you're building Angular applications, React components, or Node.js backends with TypeScript, Zontroy AI responds to your specific needs through natural language interaction, eliminating the need for complex configuration while delivering precise, type-aware assistance.
# Java
### Java Code Generator
### Introduction
Java development presents unique challenges in today's enterprise and mobile ecosystems. From building robust backend services to creating Android applications, Java developers navigate complex frameworks, strict typing requirements, and extensive libraries. Zontroy AI transforms Java development by seamlessly integrating the strongest capabilities from today's leading AI systems—Claude, ChatGPT, Gemini, Llama, Deep Seek, Qwen, and xAI—into a unified platform that responds intelligently to your Java development needs.\
This manual provides Java developers with essential guidance for leveraging Zontroy AI's features through effective prompting to enhance productivity, improve code quality, and streamline development workflows. Unlike traditional tools that require specific configuration, Zontroy AI works through natural language prompts, allowing you to describe your Java tasks and receive tailored assistance.
### Java-Specific Advantages of Zontroy AI
Zontroy AI offers several distinct advantages for Java developers:\
•**Enterprise-Ready Code Generation:** Request and receive idiomatic code for Spring, Jakarta EE, Android, and other Java frameworks\
•**Type-Safe Development:** Get assistance with Java's strong typing system, generics, and interfaces\
•**Design Pattern Implementation:** Easily implement complex design patterns with proper Java conventions\
•**Testing and Debugging Assistance:** Generate JUnit tests and receive help diagnosing complex Java issues\
•**Performance Optimization:** Get recommendations for improving Java application performance\
This manual focuses specifically on how to craft effective prompts for Java workflows, providing concise guidance for maximizing your productivity with Zontroy AI's suite of features.
### Getting Started with Prompt-Driven Java Development
#### Understanding How Prompts Work for Java
Zontroy AI responds to natural language prompts about Java development tasks. The quality and specificity of your prompts directly impact the assistance you receive. For Java development:\
1\. Describe your Java task or question in natural language\
2\. Include relevant context about your Java project\
3\. Specify any framework, JDK version, or platform requirements\
4\. Receive tailored Java code, explanations, or guidance
#### Crafting Effective Java Prompts
To get the best Java assistance, include these elements in your prompts:\
**•JDK Version:** Specify which Java version you're targeting\
Example: "Using Java 17 features, write a class that..."\
**•Framework Context:** Mention any frameworks or libraries you're using\
Example: "In my Spring Boot application, I need a service that..."\
**•Build System:** Note your build system when relevant\
Example: "For my Maven project, help me configure..."\
**•Project Purpose:** Briefly explain what your code needs to accomplish\
Example: "I'm building a REST API that processes financial transactions"
#### Providing Context for Java Projects
When working with existing Java projects, provide context in your prompts:\
**•Project Structure:** Briefly describe your Java project organization\
**•Dependencies:** Mention key libraries and frameworks in use\
**•Coding Standards:** Note any style guides or patterns you follow\
**•Platform Requirements:** Specify deployment targets (e.g., Android, cloud)\
Example context-setting prompt:\ I'm working on a Java 11 Spring Boot application with JPA for database access and JUnit 5 for testing. We follow Google's Java style guide. I need help creating a service that...
#### Framework and Environment Considerations
Different Java environments require different approaches. Specify:\
**•Enterprise Development:** Mention application servers, databases, or cloud\
platforms\
**•Android Development:** Specify Android API level, device targets, or UI frameworks\
**•Desktop Development:** Note JavaFX, Swing, or other UI technologies\
Example:\ I'm building an Android application targeting API level 30+ using Room for database access. I need help implementing a background service that syncs data periodically.
### Core Features for Java Development
#### Chat Feature for Java
The Chat feature provides interactive assistance for Java development through natural language prompts.\
**Java-Specific Prompting Techniques**\
For optimal Java assistance, structure your prompts with:\
**•Task Description:** Clearly state what you need to accomplish\
**•Code Context:** Share relevant existing code when applicable\
**•Expected Behavior:** Describe how the code should function\
**•Java Conventions:** Mention any specific coding conventions to follow\
Example prompts:\ "Create a Java utility class with methods for validating and formatting email addresses, with proper exception handling and JavaDoc comments"\
\ "Help me debug this Spring @Transactional method that's not rolling back when exceptions occur: \[paste code]"\ "Write a Java Stream pipeline that processes a list of customer objects, filters by region, groups by status, and calculates average order value"
#### Object-Oriented Programming Assistance
Request help with Java's OOP features:\ "Show me how to implement the Builder pattern for this complex Java class with many optional parameters: \[paste class]"\ "Help me refactor this code to use composition instead of inheritance for better flexibility"\ "Create a proper Java interface hierarchy for a payment processing system with different payment methods"
#### Java Debugging Assistance
When facing Java bugs:\ "I'm getting 'NullPointerException' in this method. How can I fix it and make it more robust? \[paste code]"\ "My JUnit test is failing with 'AssertionError'. What might be wrong with my implementation? \[paste code and test]"\ "This multithreaded Java code sometimes deadlocks. How can I identify and fix the concurrency issue? \[paste code]"
#### Collaborator Feature for Java
The Collaborator feature generates complete Java files based on your specifications.\
**Requesting Java File Generation**\
To get complete Java files:\ "Create a Java data access layer with repository classes for a customer management system using JPA and Hibernate"\ "Generate a complete Spring RestController for user management with endpoints for CRUD operations, proper validation, and error handling"\ "Write an Android Activity class for a login screen with form validation, API integration, and proper lifecycle management"
#### Framework-Specific Java Generation
Request code for specific frameworks:\ "Create a Spring Boot service that processes CSV files, validates the data, and stores it in a PostgreSQL database"\ "Generate a Jakarta EE EJB that implements a message-driven bean for processing orders from a JMS queue"\ "Write an Android RecyclerView adapter with view binding for displaying a list of products with images and details"
#### Java Class and Component Generation
For modular Java code:\ "Create a Java class hierarchy for a document management system with interfaces, abstract classes, and concrete implementations"\ "Generate a thread-safe Java singleton class with lazy initialization using double-checked locking"\ "Write a custom Java annotation and processor for validating method parameters at compile time"
#### Peerer Feature for Java Projects
Peerer orchestrates multi-agent AI teams specialized for Java development with your prompts.\
**Requesting Multi-Agent Java Assistance**\
Use Peerer to assemble specialized teams:\ "I need a team to help me build a Java e-commerce platform with:
* Spring Boot backend with REST APIs
* JPA/Hibernate for data access
* Spring Security for authentication
* Unit and integration testing strategy"
#### Complex Java Architecture Assistance
For large Java projects, request Peerer to:\ "I need help designing a microservices architecture using Spring Cloud. Can you create a :
1. Design the service boundaries
2. Plan the inter-service communication
3. Implement service discovery and configuration
4. Design a resilient error handling strategy"
### Model Context Protocol (MCP) Tools for Java
MCP Tools optimize interactions between different AI systems specifically for Java\
workflows.
#### Java Framework Integration
Request specialized assistance for frameworks:\ "Using MCP Tools, help me integrate a third-party payment gateway into my Spring Boot application with proper error handling and transaction management"\ "I need help setting up a Java microservices architecture with proper service discovery, configuration, and resilience patterns"\
**Enterprise Java Development**\
For enterprise projects:\ "Help me design a scalable Java backend for a high-traffic web application, including caching strategies, connection pooling, and thread management"
#### Java-Specific Workflows
**Object-Oriented Programming in Java**\
Request help with Java OOP concepts:\
***Class Design and Inheritance***\ "Show me how to design a flexible class hierarchy for a vehicle rental system with different vehicle types and rental options"\ "Help me understand when to use abstract classes vs. interfaces in Java with practical examples"\
***Design Patterns in Java***\ "Implement the Observer pattern in Java for a stock price monitoring system"\ "Show me how to use the Factory Method pattern to create different types of database connections in Java"\
***Java Enterprise Development***\
Request assistance with enterprise Java:\ "Create a Jakarta EE REST API with JAX-RS for a customer management system with proper validation and error handling"\ "Help me implement a JMS producer and consumer for asynchronous order processing in a Java EE application"\
***Spring Framework Development***\
For Spring applications:\ "Create a Spring Boot application with Spring Data JPA repositories, service layer, and REST controllers for a library management system"\ "Show me how to implement proper authentication and authorization in a Spring Security application with JWT tokens"\
***Android Development with Java***\
For Android projects:\ "Create an Android Fragment that displays a map with custom markers and info windows using Google Maps API"\ "Help me implement efficient data loading with paging and RecyclerView in my Android application"
#### ***Best Practices and Examples***
***Java Code Examples***\
Request practical code examples:\ "Show me examples of implementing thread pools in Java for parallel processing of large datasets"\ "Provide examples of proper exception handling in Java with custom exceptions and meaningful error messages"\
***Performance Optimization***\
Ask about optimizing Java:\ "What are the best practices for optimizing memory usage in a Java application with large collections?"\ "Show me how to identify and fix performance bottlenecks in this Java method: \[paste code]"\
***Security Considerations***\
Get guidance on secure Java:\ "Show me how to prevent SQL injection in JDBC queries with prepared statements and parameter binding"\ "Help me implement proper input validation and sanitization for this Java web application: \[paste code]"
### Conclusion
Zontroy AI transforms Java development by providing intelligent, prompt-based assistance that understands Java's unique challenges across enterprise, mobile, and desktop environments. By crafting effective prompts as outlined in this manual, you can leverage Zontroy AI to generate high-quality Java code, resolve complex issues, and accelerate your development workflow.\
Whether you're building Spring applications, Android apps, or enterprise systems, Zontroy AI responds to your specific needs through natural language interaction, delivering precise, context-aware assistance without requiring complex configuration.
####
# Python
### Python Code Generator
### Introduction
Python development spans diverse domains from web applications to data science, machine learning, and automation. Its flexibility and extensive ecosystem make it powerful yet challenging to master all aspects. Zontroy AI transforms Python development by seamlessly integrating the strongest capabilities from today's leading AI systems—Claude, ChatGPT, Gemini, Llama, Deep Seek, Qwen, and xAI—into a unified platform that responds intelligently to your Python development needs.\
This manual provides Python developers with essential guidance for leveraging Zontroy AI's features through effective prompting to enhance productivity, improve code quality, and streamline development workflows. Unlike traditional tools that require specific configuration, Zontroy AI works through natural language prompts, allowing you to describe your Python tasks and receive tailored assistance.
### Python-Specific Advantages of Zontroy AI
Zontroy AI offers several distinct advantages for Python developers:\
**•Ecosystem-Aware Code Generation:** Request and receive idiomatic code for Django, Flask, pandas, PyTorch, and other popular Python libraries\
**•Cross-Domain Support:** Get assistance across data science, web development, automation, and other Python domains\
**•Modern Python Features:** Leverage the latest Python syntax and patterns in your code\
**•Testing and Debugging Assistance:** Generate pytest fixtures and receive help diagnosing complex Python bugs\
**•Performance Optimization:** Get recommendations for improving Python code\
efficiency
### Getting Started with Prompt-Driven Python Development
#### Understanding How Prompts Work for Python
Zontroy AI responds to natural language prompts about Python development tasks. The quality and specificity of your prompts directly impact the assistance you receive. For Python development:\
1\. Describe your Python task or question in natural language\
2\. Include relevant context about your Python project\
3\. Specify any frameworks, libraries, or Python version requirements\
4\. Receive tailored Python code, explanations, or guidance
#### Crafting Effective Python Prompts
To get the best Python assistance, include these elements in your prompts:\
**•Python Version:** Specify which Python version you're targeting\
Example: "Using Python 3.10 features like pattern matching, write a function that..."\
**•Library Context:** Mention any libraries or frameworks you're using\
Example: "In my Django project with DRF, I need a view that..."\
**•Environment Details:** Note virtual environments or deployment targets when relevant\
Example: "For a Lambda function running Python 3.9, help me optimize..."\
**•Project Purpose:** Briefly explain what your code needs to accomplish\
Example: "I'm building a data pipeline that processes CSV files and generates reports"
#### Providing Context for Python Projects
When working with existing Python projects, provide context in your prompts:\
**•Project Structure:** Briefly describe your Python project organization\
**•Dependencies:** Mention key libraries and frameworks in use\
**•Coding Standards:** Note any style guides or patterns you follow (PEP 8, etc.)\
Example context-setting prompt:\ I'm working on a Flask application with SQLAlchemy for database access and pytest for testing. We follow PEP 8 style guidelines. I need help creating a service that...
### Core Features for Python Development
#### Chat Feature for Python
The Chat feature provides interactive assistance for Python development through\
natural language prompts.\
***Python-Specific Prompting Techniques***\
For optimal Python assistance, structure your prompts with:\
**•Task Description:** Clearly state what you need to accomplish\
**•Code Context:** Share relevant existing code when applicable\
**•Expected Behavior:** Describe how the code should function\
Example prompts:\ "Create a Python function that processes a DataFrame to identify outliers using the IQR method, with proper documentation and type hints"\ "Help me debug this generator function that's not yielding the expected sequence: \[paste code]"\ "Write a Django view that handles file uploads with proper validation, error handling, and security checks"\
***Modern Python Features***\
Request assistance with modern Python features:\ "Show me how to use structural pattern matching in Python 3.10 to parse different message formats"\ "Help me refactor this code to use dataclasses for better data management: \[paste code]"\ "Explain how to use Python's asyncio effectively for concurrent API requests"
### Collaborator Feature for Python
The Collaborator feature generates complete Python files based on your specifications.
#### Requesting Python File Generation
To get complete Python files:\ "Create a Python utility module with functions for processing and validating JSON data, with proper error handling and type hints"\ "Generate a complete Flask API for a task management system with endpoints for CRUD operations, authentication, and error handling"\ "Write a pandas data processing script that cleans, transforms, and analyzes customer transaction data from CSV files"
#### Framework-Specific Python Generation
Request code for specific frameworks:\ "Create a Django model and serializer for a blog application with categories, tags, and user authentication"\ "Generate a FastAPI application with dependency injection, Pydantic models, and SQLAlchemy integration"\ "Write a PyTorch training loop for a convolutional neural network with data augmentation and early stopping"
### Peerer Feature for Python Projects
Peerer orchestrates multi-agent AI teams specialized for Python development through your prompts.
#### Requesting Multi-Agent Python Assistance
Use Peerer to assemble specialized teams:\ "build a Python data science project with:
* Data cleaning and preprocessing with pandas
* Feature engineering and selection
* Model training with scikit-learn
* Visualization with matplotlib and seaborn"
#### Complex Python Architecture Assistance
For large Python projects, use Peerer to:\ "I need help designing a scalable architecture for a Python- based ETL system. Can you create:
1. Design the data extraction components
2. Plan the transformation pipeline
3. Structure the loading and storage mechanisms
4. Implement error handling and monitoring"
### Model Context Protocol (MCP) Tools for Python
MCP Tools optimize interactions between different AI systems specifically for Python workflows.\
Request specialized assistance for frameworks:\ "Using MCP Tools, help me integrate a machine learning model into my Flask application with proper API endpoints and error handling"\ "I need help setting up a Django project with Celery for background tasks and Redis for caching"
### Python-Specific Workflows
#### Data Science and Machine Learning
Request help with Python data science:\
***Data Analysis with pandas and numpy***\ "Show me how to efficiently clean and preprocess this messy dataset using pandas: \[describe dataset]"\ "Help me optimize this slow pandas operation that's processing a large DataFrame: \[paste code]"\
***Machine Learning with scikit-learn***\ "Create a complete machine learning pipeline in scikit-learn for a classification problem, including preprocessing, feature selection, and model evaluation"\ "Help me interpret these model evaluation metrics and suggest improvements for my classifier: \[paste metrics]"\
***Web Development with Python***\
Request assistance with Python web development:\ "Create a Django REST Framework API for a user management system with authentication, permissions, and proper serialization"\ "Show me how to implement server-side rendering with Jinja2 templates in a Flask application"\ "Help me optimize the database queries in this Django view that's causing performance issues: \[paste code]"\
***Automation and Scripting***\
Get help with Python automation:\ "Create a Python script that monitors a directory for new files and processes them according to their type"\ "Write a Selenium script to automate form submission on a website with proper error handling and retries"
#### Testing and Debugging Python Code
Request assistance with testing:\ "Generate pytest fixtures and tests for this Python module, including edge cases and error scenarios: \[paste code]"\ "Show me how to use Python's debugging tools effectively to trace this recursive function"
### Best Practices and Examples
#### Python Code Examples
Request practical code examples:\ "Show me examples of implementing the strategy pattern in Python for different sorting algorithms"\ "Provide examples of proper error handling in Python with context managers and custom exceptions"
#### Performance Optimization
Ask about optimizing Python:\ "What are the best practices for optimizing memory usage in a Python application processing large datasets?"\ "Show me how to identify and fix performance bottlenecks in this Python function: \[paste code]"
### Conclusion
Zontroy AI transforms Python development by providing intelligent, prompt-based\
assistance that understands Python's unique challenges across web development, data science, and automation domains. By crafting effective prompts as outlined in this manual, you can leverage Zontroy AI to generate high-quality Python code, resolve complex issues, and accelerate your development workflow.\
\
Whether you're building Django applications, analyzing data with pandas, or creating automation scripts, Zontroy AI responds to your specific needs through natural language interaction, delivering precise, context-aware assistance without requiring complex configuration.
# CSharp
### C# Code Generator
### 1. Introduction
Zontroy AI represents a revolutionary advancement in developer productivity, seamlessly integrating capabilities from leading AI systems into a unified platform that significantly enhances C# development workflows. As a C# developer, you gain access to a powerful suite of AI-assisted tools designed to streamline coding tasks, solve complex problems, and accelerate project delivery—all through intuitive natural language prompts.Unlike traditional development tools that require specific configurations or language settings, Zontroy AI operates through a prompt-driven approach. You simply describe what you need in natural language, and Zontroy AI leverages its deep understanding of C# programming patterns, .NET frameworks, and software architecture to deliver precise, production-ready code. This manual will guide you through effectively utilizing Zontroy AI to transform your C# development experience.
### 2. Getting Started with Zontroy AI for C# Development
Getting started with Zontroy AI is straightforward. Download and install the Zontroy AI client application compatible with your development environment. For your first interaction, try a simple prompt like: "Generate a C# utility class for converting between different date formats with XML documentation." This will demonstrate Zontroy AI's ability to produce well-structured, documented C# code based on natural language descriptions.
### 3. Core Features for C# Development
#### 3.1 Chat Feature
The Chat feature enables real-time dialogue with Zontroy AI to generate precise C# code snippets, explain concepts, or troubleshoot issues. Unlike generic coding assistants, Zontroy AI understands C# idioms and best practices.
**Example prompts:**
* "Write a C# extension method that safely converts string to nullable DateTime"
* "Explain how to implement IDisposable pattern correctly in C#"
* "Show me how to use async/await with HttpClient in C# with proper exception handling"
The Chat feature excels at providing contextual assistance, allowing you to refine requirements through conversation until you receive exactly the C# code you need.
#### 3.2 Collaborator Feature
The Collaborator feature elevates your productivity by generating complete C# files based on high-level descriptions. This is particularly valuable for creating boilerplate code, data models, or implementing design patterns.
**Example prompts:**
* "Create a complete Repository implementation for a Customer entity using Entity Framework Core in C#"
* "Generate a WebAPI controller for user authentication with JWT in ASP.NET Core"
* "Build a service class that handles Azure Blob Storage operations with proper error handling"
Collaborator understands C# project structures and can generate files that seamlessly integrate with your existing codebase.
#### 3.3 Peerer Feature
Peerer orchestrates multi-agent AI teams that combine specialized strengths from various models to tackle complex C# programming challenges end-to-end. **Example prompts:**
* "Design a scalable microservice architecture using C# and ASP.NET Core with message queue integration"
* "Create a complete Blazor WASM application with authentication, state management, and API communication"
* "Develop a C# library for processing large datasets with parallel processing capabilities"
Peerer excels at complex tasks requiring multiple perspectives, such as architecture design, performance optimization, and security implementation.
#### 3.4 MCP Tools
Model Context Protocol (MCP) Tools optimize interactions between different AI systems, ensuring coherent collaboration when working on complex C# projects. **Example prompts:**
* "Analyze this C# codebase for performance bottlenecks and suggest optimizations"
* "Review my ASP.NET Core application for security vulnerabilities"
* "Refactor this legacy C# code to use modern .NET 6 features while maintaining functionality"
MCP Tools are particularly valuable for code review, refactoring, and optimization tasks that benefit from multiple specialized AI perspectives.
### 4. C# Specific Workflows
#### 4.1 Object-Oriented Programming
Zontroy AI excels at generating robust object-oriented C# code, including class hierarchies, interfaces, and design patterns.
**Example prompt:** "Create a C# class hierarchy for a document management system with abstract base classes, interfaces, and concrete implementations following SOLID principles"
#### 4.2 LINQ and Functional Approaches
Generate efficient LINQ queries and functional programming patterns in C#. **Example prompt:** "Write a LINQ query that joins multiple collections, filters by complex conditions, and projects results into a new anonymous type with proper null handling"
#### 4.3 Asynchronous Programming
Master C#'s async/await pattern with Zontroy AI's assistance.
**Example prompt:** "Show me how to implement proper async/await patterns in a C# service that makes multiple parallel API calls while handling exceptions and cancellation"
#### 4.4 Error Handling and Debugging
Improve your application's resilience with sophisticated error handling strategies. **Example prompt:** "Generate a comprehensive exception handling strategy for a C# financial application with logging, user-friendly messages, and recovery mechanisms"
### 5. Framework Support
#### 5.1 .NET Core/.NET 5+
Zontroy AI provides specialized assistance for modern .NET development. **Example prompt:** "Create a .NET 6 worker service that processes messages from a queue, with dependency injection and configuration"
#### 5.2 ASP.NET Core
Accelerate web application and API development with framework-specific guidance.
**Example prompt:** "Generate an ASP.NET Core Web API with Entity Framework Core, authentication, and Swagger documentation"
#### 5.3 Blazor
Build interactive web UIs with C# instead of JavaScript.
**Example prompt:** "Create a Blazor component that displays and edits a data grid with sorting, filtering, and pagination"
#### 5.4 Entity Framework Core
Simplify data access with ORM-specific assistance.
**Example prompt:** "Write Entity Framework Core entities with relationships, configurations, and migrations for an order management system"
#### 5.5 Xamarin/MAUI
Develop cross-platform mobile applications with C#.
**Example prompt:** "Generate a MAUI view model with data binding, commands, and navigation for a mobile app profile page"
### 6. Best Practices
#### 6.1 Crafting Effective C# Prompts
For optimal results with C# code generation:
1. Be specific about C# version and framework
2. Include business context and requirements
3. Specify error handling expectations
4. Mention performance considerations
5. Request XML documentation when needed
**Example improved prompt:** "Create a C# 10 record type for an immutable Product entity with validation, using .NET 6 features, with proper exception handling for invalid inputs, and complete XML documentation"
#### 6.2 Optimizing Code Generation Results
Refine your results through iterative prompting:
1. Start with a high-level request
2. Review the generated code
3. Ask for specific improvements or changes
4. Request explanations for complex sections
This conversational approach yields higher quality C# code tailored to your exact needs.
### 7. Conclusion
Zontroy AI transforms C# development through its innovative prompt-driven approach, eliminating the need for complex configurations while delivering precise, high-quality code. By leveraging the Chat, Collaborator, Peerer, MCP Tools, and Offline Code Generator features, C# developers can dramatically accelerate development cycles, improve code quality, and tackle complex challenges with confidence.
The platform's deep understanding of C# programming patterns, .NET frameworks, and software architecture principles ensures that generated code follows best practices and integrates seamlessly with existing projects. Whether you're building web applications with ASP.NET Core, mobile apps with MAUI, or desktop software with WPF, Zontroy AI provides specialized assistance tailored to your specific needs. Start transforming your C# development workflow today with Zontroy AI and experience the future of AI-assisted programming.
# PHP
### PHP Code Generator
### 1. Introduction
Zontroy AI represents a revolutionary advancement in developer productivity, seamlessly integrating capabilities from leading AI systems into a unified platform that significantly enhances PHP development workflows. As a PHP developer, you gain access to a powerful suite of AI-assisted tools designed to streamline coding tasks, solve complex problems, and accelerate project delivery—all through intuitive natural language prompts.
Unlike traditional development tools that require specific configurations or language settings, Zontroy AI operates through a prompt-driven approach. You simply describe what you need in natural language, and Zontroy AI leverages its deep understanding of PHP programming patterns, frameworks, and software architecture to deliver precise, production-ready code. This manual will guide you through effectively utilizing Zontroy AI to transform your PHP development experience.
### 2. Getting Started with Zontroy AI for PHP Development
Getting started with Zontroy AI is straightforward. Download and install the Zontroy AI client application compatible with your development environment. For your first interaction, try a simple prompt like: "Generate a PHP utility class for validating email addresses with proper error handling." This will demonstrate Zontroy AI's ability to produce well-structured, documented PHP code based on natural language descriptions.
### 3. Core Features for PHP Development
#### 3.1 Chat Feature
The Chat feature enables real-time dialogue with Zontroy AI to generate precise PHP code snippets, explain concepts, or troubleshoot issues. Unlike generic coding assistants, Zontroy AI understands PHP idioms and best practices.
**Example prompts:**
* "Write a PHP function that safely handles file uploads with validation and security checks"
* "Explain how to implement dependency injection in PHP with practical examples"
* "Show me how to use PHP's PDO for database operations with prepared statements"
The Chat feature excels at providing contextual assistance, allowing you to refine requirements through conversation until you receive exactly the PHP code you need.
#### 3.2 Collaborator Feature
The Collaborator feature elevates your productivity by generating complete PHP files based on high-level descriptions. This is particularly valuable for creating boilerplate code, data models, or implementing design patterns.
**Example prompts:**
* "Create a complete Repository implementation for a Product entity using PDO in PHP"
* "Generate a RESTful API controller for user authentication with JWT in PHP"
* "Build a service class that handles image processing with proper error handling in PHP"
Collaborator understands PHP project structures and can generate files that seamlessly integrate with your existing codebase.
#### 3.3 Peerer Feature
Peerer orchestrates multi-agent AI teams that combine specialized strengths from various models to tackle complex PHP programming challenges end-to-end.
**Example prompts:**
* "Design a scalable microservice architecture using PHP with API Gateway pattern"
* "Create a complete Laravel e-commerce application with payment processing and inventory management"
* "Develop a PHP content management system with custom post types and user roles"
Peerer excels at complex tasks requiring multiple perspectives, such as architecture design, performance optimization, and security implementation.
#### 3.4 MCP Tools
Model Context Protocol (MCP) Tools optimize interactions between different AI systems, ensuring coherent collaboration when working on complex PHP projects.
**Example prompts:**
* "Analyze this PHP codebase for performance bottlenecks and suggest optimizations"
* "Review my Laravel application for security vulnerabilities"
* "Refactor this legacy PHP code to use modern PHP 8 features while maintaining functionality"
MCP Tools are particularly valuable for code review, refactoring, and optimization tasks that benefit from multiple specialized AI perspectives.
### 4. PHP Specific Workflows
#### 4.1 Object-Oriented Programming
Zontroy AI excels at generating robust object-oriented PHP code, including class hierarchies, interfaces, and traits.
**Example prompt:** "Create a PHP class hierarchy for a payment processing system with abstract base classes, interfaces, and concrete implementations following SOLID principles"
#### 4.2 Modern PHP Features
Generate code that leverages the latest PHP language features for cleaner, more efficient code.
**Example prompt:** "Write a PHP 8 class that uses attributes, named arguments, constructor property promotion, and match expressions for a data validation system"
#### 4.3 Database Interactions
Simplify database operations with Zontroy AI's assistance.
**Example prompt:** "Generate a PHP data access layer with PDO that implements repository pattern for a customer management system with proper transaction handling"
#### 4.4 API Development
Accelerate API development with framework-agnostic or framework-specific guidance.
**Example prompt:** "Create a RESTful API endpoint in PHP that handles authentication, validation, rate limiting, and returns JSON responses with proper HTTP status codes"
### 5. Framework Support
#### 5.1 Laravel
Zontroy AI provides specialized assistance for Laravel development.
**Example prompt:** "Generate a Laravel Eloquent model with relationships, scopes, and custom query methods for an order management system"
#### 5.2 Symfony
Accelerate development with Symfony-specific guidance.
**Example prompt:** "Create a Symfony controller with Doctrine ORM, form handling, and Twig templates for a user management module"
#### 5.3 WordPress
Simplify theme and plugin development for WordPress.
**Example prompt:** "Generate a WordPress custom post type with taxonomies, meta fields, and REST API support for a recipe management system"
#### 5.4 Drupal
Streamline Drupal module development.
**Example prompt:** "Create a Drupal 9 module with custom entity types, configuration forms, and block plugins for a content rating system"
### 6. Best Practices
#### 6.1 Crafting Effective PHP Prompts
For optimal results with PHP code generation:
1. Be specific about PHP version and framework
2. Include business context and requirements
3. Specify error handling expectations
4. Mention performance considerations
5. Request PHPDoc documentation when needed
**Example improved prompt:** "Create a PHP 8.1 class for handling API requests with proper exception handling, PSR-7 message interfaces, comprehensive logging, and complete PHPDoc documentation"
#### 6.2 Optimizing Code Generation Results
Refine your results through iterative prompting:
1. Start with a high-level request
2. Review the generated code
3. Ask for specific improvements or changes
4. Request explanations for complex sections
This conversational approach yields higher quality PHP code tailored to your exact needs.
### 7. Conclusion
Zontroy AI transforms PHP development through its innovative prompt-driven approach, eliminating the need for complex configurations while delivering precise, high-quality code. By leveraging the Chat, Collaborator, Peerer, MCP Tools, and Offline Code Generator features, PHP developers can dramatically accelerate development cycles, improve code quality, and tackle complex challenges with confidence.
The platform's deep understanding of PHP programming patterns, frameworks, and software architecture principles ensures that generated code follows best practices and integrates seamlessly with existing projects. Whether you're building web applications with Laravel, content management systems with WordPress, or APIs with Symfony, Zontroy AI provides specialized assistance tailored to your specific needs.Start transforming your PHP development workflow today with Zontroy AI.
