DEV Community: Callgent

🥙 Callgentive UI - Home-Cooked Software Development

Callgent — Mon, 17 Jun 2024 00:00:00 +0000

AI Large Language Models (LLMs) are ushering in a new golden age of Home-Cooked Software. and callgent is providing the solid infrastructure and solutions to make it happen. Let's take a look at how.

What is Generative UI?

From now on, forget the traditional software paradigm.

Imagine if we treated every interaction between a user and an app as a chat, with the only difference being that the content of the chat is not text, but rather a collection of widgets.

Users interact with widgets to send chat requests to AI agents, which then decide how to process the request, encapsulate the result in widgets, and present it to the user in a certain way.

The underlying layer of the chat is still textual + agents, but the interaction between the user and the app will now take place through a visual widget UI instead of text.

:::tip
From the end-user's perspective, a Generative App is no different from a traditional app (although a Generative App may appear more personalized).
:::

Callgentive UI

How does callgent leverage generative UI, as we name it Callgentive UI.

A picture is worth a thousand words:

With predefined business services and standard widgets, the Home-Cooked Software works as follows,

The landing pages are generative UI of widgets generated from some initializing Agent prompts.
As user interacts with the widgets, the interactions are transformed into a chat request.
The backend Callgent maps the chat requests to business service invocations, and gets response data from services.
The Callgent makes the response data into a set of widgets, and presents it to the user.

How does it work?

Callgent's core functionality is to do native function-calling to orchestrate business services.

Callgent has server endpoints and client endpoints to adapt various invocation scenarios.

Specifically, widget based User Interface, is just one more type of client endpoints, to adapt human interactions.

🚀 5 Reasons Why Callgent.com is Revolutionizing Business Operations

Callgent — Sat, 18 May 2024 09:36:46 +0000

Introduction

In today's fast-paced business world, the demand for streamlined operations and seamless integration of disparate systems is more pressing than ever. Callgent emerges as a groundbreaking solution, crafted to address these challenges head-on. This article explores the unique aspects of Callgent that simplify business processes and enhance operational efficiency.

The Genesis of Callgent.com

Callgent was created with a clear mission: to develop a robust enterprise operation platform capable of effortlessly tracking and processing business tickets from customers or internal systems. we have these initial thoughts:

In a nutshell, we grappled the key issues plaguing businesses:

Diverse and Disconnected Systems: Businesses often struggle with integrating diverse systems that are not designed to work together.
Varying User Roles and Needs: Each user within a business has unique roles and requirements that need tailored solutions.
Mixture of Data Types: Handling both structured and unstructured data effectively is a significant challenge.
Demand for Automation: There is a critical need for automated workflows and processes to improve efficiency and reduce human error.

Core Features of Callgent

Effortless System Integration

Callgent stands out for its ability to integrate heterogeneous systems without the need for coding. This means that businesses do not have to invest time and resources in learning new APIs. The platform uses AI-powered services to facilitate user and system interactions, making the integration smooth and effortless.

Advanced AI Capabilities

The platform's AI capabilities are particularly noteworthy. Callgent employs semantic data mapping and persistent asynchronous operations, which allow for progressive system and user invocation. These features ensure that the system understands and processes data efficiently, regardless of its format.

Natural Language Workflow Automation

Callgent's natural language Standard Operating Procedure (SOP) orchestration allows users to automate complex workflows using simple language commands. This makes it easy for non-technical users to streamline their operations in documentations.

Successful Integration Stories

Callgent's effectiveness is proven by its successful integration with various tools and platforms, such as Slack, Zendesk, and Kubernetes (k8s) services. This integration enables users to:

Invoke related services through APIs with responses via Slack or email.
Interact with k8s services using natural language commands directly in Slack.
Ensure that k8s exceptions are integrated into the ticket processing workflow without disrupting the user experience.

Embracing Open Source and Community

In an exciting development, Callgent is now transitioning to an open-source model. This move will undoubtedly foster a community of developers and users who can contribute to and benefit from the platform. Callgent invites users to try out the platform, share feedback, and even contribute to its development through GitHub.

Conclusion

Callgent signifies a significant leap in business operation platforms, providing a seamless, integrated experience that caters to all systems and users. With its no-code integration, AI-driven capabilities, and user-friendly design, Callgent is poised to revolutionize the enterprise operations landscape. As it enters its open-source phase, the potential for growth and innovation is limitless.

Dive Deeper into Callgent: Get Started with Callgent

Share Your Thoughts: Join the Callgent Community

Be Part of Callgent's Development: GitHub Repository

Nestjs + Prisma, transaction propagation & test rollback & multi-tenancy

Callgent — Sat, 16 Mar 2024 00:00:00 +0000

Prisma interactive transaction

Prisma is great. Yet it's support for interactive transaction is currently limited (Up to v5+),

// interactive transaction
prisma.$transaction([array_of_operations,]);

prisma.$transaction(async (tx) => {
    // dependent operations
});

Container managed transactions

As we integrate Prisma to NestJs, we want cross Services transaction propagation, container managed tx is even better. After some investigation, we come to @nestjs-cls/transactional,

@Injectable()
export class MyService {
  constructor(
    private readonly txHost: TransactionHost<TransactionalAdapterPrisma>,
    private readonly anotherService: AnotherService,
  ) {}

@Transactional()
  async myMethod(){
    const prisma = this.txHost.tx as PrismaClient;

    // db operations1
    await this.anotherService.anotherMethod(); // db operations2
    // db operations3
  }
}

Just decorate your Service method with @Transactional(), it will automatically propagate the transaction across service calls. Under the hood, it uses cls (continuation-local storage) to manage the transaction context.

Rollback is triggered by just throwing an exception.

Setup the module

    ClsModule.forRoot({
      plugins: [
        new ClsPluginTransactional({
          imports: [PrismaModule], // comment this line, if you have existing PrismaModule
          middleware: { mount: true }, // mount plugin as nestjs middleware
          adapter: new TransactionalAdapterPrisma({ // Prisma adaptor
            // the original PrismaService is wrapped into the adaptor
            prismaInjectionToken: PrismaService,
          }),
        }),
      ],
    }),

More complicated use cases, please read it's documentation.

Transactions in e2e test cases

After each test case, we need to rollback the transaction, preventing side-effects. Thankfully again, it comes to @chax-at/transactional-prisma-testing,

// the PrismaService proxy
let prismaService;

// This function must be called before every test
async function beforeEachFn(): Promise<void> {
  if(prismaTestingHelper == null) {
    prismaTestingHelper = new PrismaTestingHelper(app.get(PrismaService));
    prismaService = prismaTestingHelper.getProxyClient();
  }
  await prismaTestingHelper.startNewTransaction();
}

// This function must be called after every test
function afterEachFn(): void {
  prismaTestingHelper?.rollbackCurrentTransaction();
}

Integrated with @nestjs-cls/transactional

We need this orderly wrapping,

@nestjs-cls/transactional
  └─@chax-at/transactional-prisma-testing
      └─original-PrismaService

So we override PrismaService with testing proxy in beforeAllFn,

import { Test } from '@nestjs/testing';

let prismaTestingHelper, prismaServiceForTest;

const beforeAllFn = () => {
  const moduleFixtureForTest = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(PrismaService)
      .useFactory({ factory: (originalPrisma: PrismaService) => {
          if (prismaTestingHelper == null) {
            prismaTestingHelper = new PrismaTestingHelper(originalPrisma);
            prismaServiceForTest = prismaTestingHelper.getProxyClient();
          }
          return prismaServiceForTest;
        },
        inject: [PrismaService],
      })
      .compile();

  const app: NestFastifyApplication =
    await moduleFixtureForTest.createNestApplication(new FastifyAdapter(), {
      abortOnError: false,
      bufferLogs: false,
    });

  // ... ...
}

Don't forget to call these method around each test,

describe('AppController (e2e)', () => {
  beforeAll(beforeAllFn);
  afterAll(afterAllFn);
  beforeEach(beforeEachFn);
  afterEach(afterEachFn);

  it('/api (GET)', () => {
    // db operations are rollbacked after each test automatically.
  });

🎉 🎉 🎉

Transparent multi-tenancy based on postgreSQL

We have a multi-tenant application, Botlet.IO, tenants data are isolated based on the tenant_id column in db tables.

By design, we want tenant isolation transparently implemented, so we don't need to add tenant_id to every query.

  // by default, we want the below query to be tenant isolated,
  // only users in context tenant are returned.
  prisma.$queryRaw`SELECT * FROM users`

We utilize the postgreSQL row level security(RLS), following this article to achieve transparent tenant isolation.

:::note
RLS is only applicable in postgreSQL
:::

How to implement

in schema.prisma file, set db column tenant_id default value to context variable tenancy.tenantId,

   tenant_id Int  @default(dbgenerated("(current_setting('tenancy.tenantId'))::int"))

enable postgres row level security(RLS), so that we can filter data by tenant_id automatically:
write SQL in prisma/migrations/01_row_level_security/migration.sql,
please refer this real example
on each request, preset tenant_id into cls context, refer to auth-logined.listener.ts,

   cls.set('TENANT_ID', curentUser.tenantId);

extend PrismaClient to set tenant_id before any query, refer to prisma-tenancy.provider.ts,

   SELECT set_config('tenancy.tenantId', cls.get('TENANT_ID') ...

if you want to bypass rls, for example, by admin, or looking up the logon user to determine their tenant ID:

   CREATE POLICY bypass_rls_policy ON "User" USING (current_setting('tenancy.bypass_rls', TRUE)::text = 'on');

then when you want to bypass rls, you must set tenancy.bypass_rls to on before running the query, refer to prisma-tenancy.service.ts,

   await prisma.$executeRaw`SELECT set_config('tenancy.bypass_rls', 'on', TRUE)`;

how it works

tenantId is set into cls context on each request from current user.
PrismaClient is extended on $allOperations to set tenantId into db variable tenancy.tenantId before any query.
postgreSQL RLS is enabled, so that all queries will be filtered by tenancy.tenantId automatically.
on db insert operation, tenancy.tenantId is set into tenant_id column as default value.

Integrate them all

As we extended PrismaClient to enable transparent multi-tenancy, now the wrapping order is changed to,

@nestjs-cls/transactional
  └─@chax-at/transactional-prisma-testing
      └─**tenancy-extended-prisma**
        └─original-PrismaService

extend PrismaClient as name TENANTED_PRISMA_SERVICE

@Global()
@Module({
  imports: [PrismaModule], // original PrismaModule
  providers: [ {
    provide: TENANTED_PRISMA_SERVICE,
    // ...
  } ],
  exports: [TENANTED_PRISMA_SERVICE], // extended PrismaClient
})
export class PrismaTenancyOnPgModule {}

replace PrismaService with TENANTED_PRISMA_SERVICE in prismaInjectionToken,
replace PrismaService with TENANTED_PRISMA_SERVICE in beforeAllFn,