OpenClaw के साथ कस्टम AI एजेंट बनाना: डेवलपर गाइड

उत्पादन के लिए तैयार AI एजेंट बनाना चैटबॉट लिखने के समान नहीं है। एजेंटों को संदर्भ को समझना होगा, अधूरी जानकारी पर तर्क करना होगा, बहु-चरणीय योजनाओं को क्रियान्वित करना होगा और विफलताओं से उबरना होगा - यह सब मानव पर्यवेक्षण के बिना। ओपनक्लाव एक एंटरप्राइज़ एआई एजेंट प्लेटफ़ॉर्म है जो विशेष रूप से परिचालन स्वायत्तता के इस स्तर के लिए बनाया गया है, जो डेवलपर्स को पहले दिन से एक संरचित रनटाइम, एक कौशल संरचना मॉडल और प्रथम श्रेणी अवलोकन प्रदान करता है।

यह मार्गदर्शिका उन इंजीनियरों के लिए लिखी गई है जो शून्य से तैनात, निगरानी किए गए ओपनक्लॉ एजेंट तक जाना चाहते हैं। हम आर्किटेक्चर आंतरिक, कौशल संलेखन, मेमोरी प्रबंधन, ऑर्केस्ट्रेशन हुक और तैनाती पैटर्न को कवर करते हैं जो एजेंटों को उत्पादन भार के तहत विश्वसनीय रखते हैं।

मुख्य बातें

• ओपनक्लॉ एजेंट कौशल (परमाणु क्षमताओं), मेमोरी परतों और एक ऑर्केस्ट्रेटर से बने होते हैं जो निष्पादन अनुक्रमों की योजना बनाते हैं।
• एजेंट मेनिफेस्ट फ़ाइल रनटाइम से पहले सभी निर्भरता, अनुमतियाँ और टूल बाइंडिंग की घोषणा करती है।
• कौशल स्टेटलेस फ़ंक्शन हैं जो टाइप किए गए इनपुट को स्वीकार करते हैं और टाइप किए गए आउटपुट को उत्सर्जित करते हैं - टेस्टेबिलिटी अंतर्निहित होती है।
• वर्किंग मेमोरी, एपिसोड मेमोरी और लॉन्ग-टर्म मेमोरी टियर अलग-अलग अवधारण और पुनर्प्राप्ति आवश्यकताओं को पूरा करते हैं।
• हुक (प्री-रन, पोस्ट-रन, ऑन-एरर) आपको कोर स्किल कोड को संशोधित किए बिना मॉनिटरिंग, रेट लिमिटिंग और फ़ॉलबैक लॉजिक इंजेक्ट करने देता है।
• ओपनक्लॉ का सैंडबॉक्स मोड आपको लाइव एपीआई कॉल के बिना डिबगिंग के लिए स्थानीय स्तर पर उत्पादन निशान को फिर से चलाने की सुविधा देता है।
• मल्टी-एजेंट हैंडऑफ़ एक टाइप की गई संदेश बस का उपयोग करते हैं - एजेंटों के बीच कोई कच्ची स्ट्रिंग नहीं गुजरती।
• ECOSIRE एंटरप्राइज़ टीमों के लिए प्रबंधित ओपनक्लॉ कार्यान्वयन, कस्टम कौशल लाइब्रेरी और चल रहे अनुकूलन प्रदान करता है।

---

ओपनक्लॉ एजेंट मॉडल को समझना

प्रत्येक ओपनक्लॉ एजेंट चार आदिमों की एक संरचना है: कौशल, मेमोरी, टूल्स, और एक ऑर्केस्ट्रेटर।

कौशल एजेंट क्षमता की परमाणु इकाइयाँ हैं। स्किल एक फ़ंक्शन है जो टाइप किए गए इनपुट स्कीमा को स्वीकार करता है और टाइप किए गए आउटपुट स्कीमा को लौटाता है। कौशल सिंक्रोनस या एसिंक्रोनस हो सकते हैं, और वे अपनी बाहरी निर्भरता को स्पष्ट रूप से घोषित करते हैं। उदाहरण: ParseInvoice, SendSlackMessage, QueryCRMContact, GenerateReport।

टूल्स बाहरी सिस्टम बाइंडिंग हैं। OpenClaw REST API, डेटाबेस, फ़ाइल सिस्टम, ब्राउज़र और संदेश कतारों के लिए अंतर्निहित टूल के साथ आता है। आप एजेंट मेनिफेस्ट में टूल पंजीकृत करते हैं और उन्हें निर्भरता इंजेक्शन के माध्यम से रनटाइम पर कौशल में इंजेक्ट करते हैं।

मेमोरी को तीन स्तरों में व्यवस्थित किया गया है। वर्किंग मेमोरी वर्तमान कार्य स्थिति-एजेंट का स्क्रैचपैड रखती है। एपिसोड मेमोरी पूर्ण किए गए कार्य इतिहास को संग्रहीत करती है जो वर्तमान सत्र के भीतर अर्थ संबंधी समानता द्वारा पुनर्प्राप्त करने योग्य हैं। दीर्घकालिक मेमोरी सभी सत्रों में बनी रहती है और सीखे गए तथ्यों, उपयोगकर्ता प्राथमिकताओं और डोमेन ज्ञान को संग्रहीत करती है।

आर्केस्ट्रेटर तर्क का मूल है। यह एक लक्ष्य विवरण प्राप्त करता है, उपलब्ध कौशल रजिस्ट्री पर सवाल उठाता है, एक निष्पादन योजना बनाता है, और प्रत्येक चरण की निगरानी करता है। जब कोई कौशल विफल हो जाता है, तो ऑर्केस्ट्रेटर निर्णय लेता है कि उसे पुनः प्रयास करना है, वैकल्पिक कौशल को प्रतिस्थापित करना है, या किसी मानव तक आगे बढ़ना है।

एकल एजेंट के लिए आर्किटेक्चर आरेख इस तरह दिखता है:

User Request
     ↓
[ Orchestrator ]
     ↓ plan
[ Skill Selector ] → [ Skill Registry ]
     ↓ execute
[ Skill Instance ]
     ↓ tool calls
[ Tool Layer ] → [ External Systems ]
     ↓ result
[ Memory Writer ]
     ↓ store
[ Working / Episode / Long-Term Memory ]
     ↓ next step or done
[ Orchestrator ] → response

यह लूप तब तक जारी रहता है जब तक ऑर्केस्ट्रेटर यह निर्धारित नहीं कर लेता कि लक्ष्य संतुष्ट हो गया है या रुकने की स्थिति नहीं आ गई है।

---

अपना विकास परिवेश स्थापित करना

अपना पहला कौशल लिखने से पहले, आपको ओपनक्लॉ एसडीके और एक स्थानीय एजेंट रनटाइम की आवश्यकता है।

npm install @openclaw/sdk @openclaw/runtime @openclaw/cli
npx openclaw init my-agent --template=typescript

init कमांड इस संरचना के साथ एक प्रोजेक्ट तैयार करता है:

my-agent/
  agent.manifest.json   # Agent declaration
  skills/               # Skill implementations
  tools/                # Tool registrations
  memory/               # Memory adapter config
  tests/                # Skill and integration tests
  .openclaw/            # Local runtime state

agent.manifest.json सबसे महत्वपूर्ण फ़ाइल है. यह वह सब कुछ घोषित करता है जो OpenClaw को आपके एजेंट को बूटस्ट्रैप करने के लिए चाहिए:

{
  "name": "invoice-processor",
  "version": "1.0.0",
  "runtime": "node-20",
  "skills": [
    "skills/extract-line-items.ts",
    "skills/validate-vendor.ts",
    "skills/post-to-erp.ts"
  ],
  "tools": {
    "erp": { "type": "rest", "baseUrl": "${ERP_BASE_URL}", "auth": "bearer" },
    "storage": { "type": "s3", "bucket": "${DOCS_BUCKET}" }
  },
  "memory": {
    "working": { "ttl": 3600 },
    "episode": { "backend": "redis", "maxItems": 500 },
    "longTerm": { "backend": "postgres", "table": "agent_facts" }
  },
  "permissions": ["read:invoices", "write:erp", "read:vendors"]
}

पर्यावरण चर को रनटाइम पर इंजेक्ट किया जाता है और मैनिफ़ेस्ट में कभी संग्रहीत नहीं किया जाता है।

---

अपना पहला कौशल लिखना

कौशल एक सख्त अनुबंध का पालन करते हैं। वे घोषित स्कीमा से मेल खाने वाले input ऑब्जेक्ट को स्वीकार करते हैं, इंजेक्ट किए गए tools और memory प्राप्त करते हैं, और एक output ऑब्जेक्ट लौटाते हैं या टाइप किए गए SkillError को फेंक देते हैं।

import { defineSkill, SkillError } from "@openclaw/sdk";
import { z } from "zod";

const ExtractLineItemsInput = z.object({
  documentUrl: z.string().url(),
  documentType: z.enum(["invoice", "receipt", "purchase-order"]),
});

const ExtractLineItemsOutput = z.object({
  lineItems: z.array(
    z.object({
      description: z.string(),
      quantity: z.number(),
      unitPrice: z.number(),
      total: z.number(),
    })
  ),
  confidence: z.number().min(0).max(1),
});

export const ExtractLineItems = defineSkill({
  name: "extract-line-items",
  description: "Extracts line items from a document using OCR and LLM parsing",
  input: ExtractLineItemsInput,
  output: ExtractLineItemsOutput,
  tools: ["storage"],
  async run({ input, tools, memory }) {
    const fileBuffer = await tools.storage.get(input.documentUrl);
    if (!fileBuffer) {
      throw new SkillError("DOCUMENT_NOT_FOUND", `No document at ${input.documentUrl}`);
    }

    // OCR + LLM extraction logic here
    const extracted = await runOcrPipeline(fileBuffer);

    await memory.working.set("lastExtraction", extracted);

    return {
      lineItems: extracted.items,
      confidence: extracted.confidence,
    };
  },
});

कौशल के लिए मुख्य डिज़ाइन नियम:

• इनपुट पर कोई दुष्प्रभाव नहीं: कौशल को अपने इनपुट ऑब्जेक्ट को संशोधित नहीं करना चाहिए।
• टाइप की गई त्रुटियां: हमेशा SkillError को मशीन-पठनीय कोड के साथ डालें, सामान्य Error के साथ नहीं।
• उपकरण निर्भरताएँ घोषित करें: केवल tools सरणी में घोषित उपकरण ही इंजेक्ट किए जाते हैं। अघोषित उपकरण स्टार्टअप सत्यापन त्रुटि का कारण बनते हैं।
• स्पष्ट रूप से स्मृति में लिखें: कौशल स्वचालित रूप से स्थिति को बनाए नहीं रखते हैं। जानबूझकर memory.working.set() पर कॉल करें।

---

अभ्यास में स्मृति प्रबंधन

तीन मेमोरी टियर अलग-अलग उद्देश्यों को पूरा करते हैं, और एजेंट की शुद्धता के लिए सही टियर चुनना महत्वपूर्ण है।

वर्किंग मेमोरी एक इन-प्रोसेस की-वैल्यू स्टोर है जो एकल कार्य चलाने की अवधि के लिए रहता है। आउटपुट श्रृंखला से गुजरे बिना कौशल के बीच मध्यवर्ती परिणाम पारित करने के लिए इसका उपयोग करें। जब ऑर्केस्ट्रेटर पूरा हो जाता है या समय समाप्त हो जाता है तो यह स्वचालित रूप से साफ़ हो जाता है।

// Skill A writes
await memory.working.set("vendorId", "VND-4521");

// Skill B reads
const vendorId = await memory.working.get("vendorId");

एपिसोड मेमोरी एक सिमेंटिक सर्च स्टोर है। जब कोई कार्य पूरा हो जाता है, तो ऑर्केस्ट्रेटर वैकल्पिक रूप से एपिसोड मेमोरी में एम्बेड करके एक सारांश लिखता है। भविष्य के कार्य अपने तर्क को सूचित करने के लिए समान पिछले एपिसोड को पुनः प्राप्त कर सकते हैं।

// Query past episodes
const relatedEpisodes = await memory.episode.search(
  "invoice from Acme Corp with disputed line items",
  { topK: 3, minScore: 0.75 }
);

दीर्घकालिक मेमोरी आपके एजेंट का सतत ज्ञान आधार है। इसका उपयोग उन तथ्यों के लिए करें जो सभी सत्रों में जीवित रहने चाहिए: विक्रेता वर्गीकरण नियम, उपयोगकर्ता प्राथमिकताएँ, सीखी गई डोमेन बाधाएँ।

// Store a learned fact
await memory.longTerm.upsert({
  key: `vendor:${vendorId}:paymentTerms`,
  value: "NET-30",
  source: "invoice-2024-0312",
  confidence: 0.9,
});

एक सामान्य गलती दीर्घकालिक स्मृति में अधिक लिखना है। इसे स्थिर, उच्च आत्मविश्वास वाले तथ्यों के लिए रखें। अल्पकालिक तर्क कार्यशील स्मृति में होता है।

---

अवलोकन और नियंत्रण के लिए जीवनचक्र हुक

OpenClaw प्रति कौशल निष्पादन के लिए चार जीवनचक्र हुक उजागर करता है: preRun, postRun, onError, और onTimeout। एजेंट मेनिफ़ेस्ट में या अपनी बूटस्ट्रैप फ़ाइल में प्रोग्रामेटिक रूप से हुक पंजीकृत करें।

import { AgentRuntime } from "@openclaw/runtime";

const agent = new AgentRuntime({ manifest: "./agent.manifest.json" });

agent.useHook("preRun", async (ctx) => {
  ctx.metadata.startTime = Date.now();
  console.log(`[${ctx.skill}] starting with input keys: ${Object.keys(ctx.input)}`);
});

agent.useHook("postRun", async (ctx) => {
  const elapsed = Date.now() - ctx.metadata.startTime;
  metrics.record("skill.duration", elapsed, { skill: ctx.skill });
});

agent.useHook("onError", async (ctx) => {
  if (ctx.error.code === "RATE_LIMIT_EXCEEDED") {
    await sleep(ctx.error.retryAfterMs);
    return "retry";
  }
  alerting.send(`Skill ${ctx.skill} failed: ${ctx.error.message}`);
  return "escalate";
});

onError हुक रिटर्न मान ऑर्केस्ट्रेटर व्यवहार को नियंत्रित करता है: "retry" एक पुनः प्रयास (कॉन्फ़िगर अधिकतम तक) ट्रिगर करता है, "escalate" कार्य को मानव कतार में रूट करता है, "fail" कार्य को तुरंत समाप्त करता है।

---

अलगाव में कौशल का परीक्षण

क्योंकि कौशल में टाइप किए गए इनपुट और आउटपुट होते हैं, यूनिट परीक्षण सीधा होता है। OpenClaw की परीक्षण उपयोगिताएँ सभी टूल इंटरफ़ेस का नकली कार्यान्वयन प्रदान करती हैं।

import { testSkill } from "@openclaw/testing";
import { ExtractLineItems } from "../skills/extract-line-items";

describe("ExtractLineItems", () => {
  it("extracts items from a valid invoice", async () => {
    const result = await testSkill(ExtractLineItems, {
      input: {
        documentUrl: "s3://test-bucket/invoice-001.pdf",
        documentType: "invoice",
      },
      mocks: {
        storage: {
          get: jest.fn().mockResolvedValue(samplePdfBuffer),
        },
      },
    });

    expect(result.lineItems).toHaveLength(3);
    expect(result.confidence).toBeGreaterThan(0.8);
  });

  it("throws DOCUMENT_NOT_FOUND for missing file", async () => {
    await expect(
      testSkill(ExtractLineItems, {
        input: { documentUrl: "s3://test-bucket/missing.pdf", documentType: "invoice" },
        mocks: { storage: { get: jest.fn().mockResolvedValue(null) } },
      })
    ).rejects.toMatchObject({ code: "DOCUMENT_NOT_FOUND" });
  });
});

एकीकरण परीक्षणों के लिए सैंडबॉक्स मोड का उपयोग करें। सैंडबॉक्स आपके वर्तमान कौशल कोड के विरुद्ध रिकॉर्ड किए गए उत्पादन निशानों को फिर से चलाता है, लाइव सिस्टम तक पहुंचने से पहले प्रतिगमन को पकड़ता है।

npx openclaw sandbox replay --trace=traces/invoice-20240315.json

---

उत्पादन में तैनाती

OpenClaw एजेंटों को डॉकर कंटेनर, सर्वर रहित फ़ंक्शन या लंबे समय तक चलने वाली प्रक्रियाओं के रूप में तैनात किया जा सकता है। एंटरप्राइज़ परिनियोजन के लिए अनुशंसित पैटर्न कार्य कतार के पीछे एक कंटेनरीकृत एजेंट पूल है।

FROM openclaw/runtime:node-20
WORKDIR /agent
COPY package.json pnpm-lock.yaml ./
RUN pnpm install --frozen-lockfile
COPY . .
RUN npx openclaw build
CMD ["npx", "openclaw", "serve", "--workers=4"]

उच्च-थ्रूपुट परिदृश्यों के लिए, एजेंट पूल को ऑटोस्केलिंग नियमों के साथ कॉन्फ़िगर करें। ओपनक्लॉ रनटाइम कतार की गहराई, कौशल विलंबता प्रतिशत, त्रुटि दर और मेमोरी उपयोग के लिए /metrics पर प्रोमेथियस मेट्रिक्स को उजागर करता है - इन्हें अपने अलर्टिंग स्टैक से कनेक्ट करें।

लाइव होने से पहले प्रोडक्शन चेकलिस्ट:

• सभी पर्यावरण चर एक सीक्रेट मैनेजर (AWS सीक्रेट मैनेजर, हाशीकॉर्प वॉल्ट) में हैं, .env फ़ाइलों में नहीं।
• मेमोरी बैकएंड (रेडिस, पोस्टग्रेएसक्यूएल) में कनेक्शन पूलिंग कॉन्फ़िगर की गई है।
• maxConcurrentTasks सेटिंग आपकी बुनियादी ढांचा क्षमता से मेल खाती है।
• बाहरी टूल कॉल पर दर सीमा विक्रेता एपीआई सीमा से मेल खाती है।
• पुनः प्रयास समाप्त करने वाले कार्यों के लिए एक डेड-लेटर कतार कॉन्फ़िगर की गई है।
• वितरित ट्रेसिंग (ओपनटेलीमेट्री) सक्षम है और निशान आपके अवलोकन मंच पर प्रवाहित हो रहे हैं।

---

अक्सर पूछे जाने वाले प्रश्न

ओपनक्लॉ ऑर्केस्ट्रेटर यह कैसे तय करता है कि आगे कौन सा कौशल चलाना है?

ऑर्केस्ट्रेटर लक्ष्य अपघटन और कौशल मिलान के संयोजन का उपयोग करता है। यह शीर्ष-स्तरीय लक्ष्य को उप-लक्ष्यों में तोड़ता है, फिर प्रत्येक उप-लक्ष्य के विवरण के विरुद्ध अर्थ संबंधी समानता का उपयोग करके कौशल रजिस्ट्री पर सवाल उठाता है। कौशल को प्रासंगिकता स्कोर, निर्भरता उपलब्धता और ऐतिहासिक सफलता दर के आधार पर क्रमबद्ध किया जाता है। ऑर्केस्ट्रेटर कौशल निष्पादन का एक निर्देशित चक्रीय ग्राफ बनाता है और शुरू करने से पहले निर्भरता का समाधान करता है।

क्या एक कौशल दूसरे कौशल को सीधे कॉल कर सकता है?

नहीं—कौशलों को सीधे अन्य कौशलों को नहीं बुलाना चाहिए। क्रॉस-कौशल समन्वय ऑर्केस्ट्रेटर की जिम्मेदारी है। यदि आपको कौशल बी चलने से पहले कौशल ए के आउटपुट की आवश्यकता है, तो ऑर्केस्ट्रेटर योजना में निर्भरता घोषित करें। यह कौशल को राज्यविहीन और व्यक्तिगत रूप से परीक्षण योग्य रखता है। अपवाद समग्र कौशल है, जिसे स्पष्ट रूप से ऑर्केस्ट्रेशन प्राइमेटिव के रूप में चिह्नित किया गया है।

क्या होता है जब किसी कौशल निष्पादन के दौरान कोई बाहरी एपीआई बंद हो जाती है?

onError हुक विफलता को रोकता है। यदि हुक "retry" लौटाता है, तो ऑर्केस्ट्रेटर कॉन्फ़िगर किए गए बैकऑफ़ अंतराल की प्रतीक्षा करता है और कौशल का पुनः प्रयास करता है। थकाऊ पुनर्प्रयास के बाद, कार्य मृत-अक्षर कतार में चला जाता है। यदि आपके पास समान क्षमता के लिए फ़ॉलबैक कौशल पंजीकृत है, तो ऑर्केस्ट्रेटर हार मानने से पहले इसे आज़माएगा। आंशिक कार्य स्थिति को वर्किंग मेमोरी में संरक्षित किया जाता है ताकि कार्य अंतिम सफल कौशल से फिर से शुरू हो सके।

आप उन रहस्यों को कैसे संभालते हैं जिनकी कौशल को रनटाइम पर आवश्यकता होती है?

एजेंट मेनिफ़ेस्ट में घोषित उपकरण स्टार्टअप पर क्रेडेंशियल्स के साथ प्रारंभ किए जाते हैं, प्रति-कौशल के साथ नहीं। आपका रहस्य प्रबंधक कंटेनर स्टार्टअप पर मेनिफेस्ट (${ERP_BASE_URL}, ${DOCS_BUCKET}, आदि) में संदर्भित पर्यावरण चर को पॉप्युलेट करता है। कौशल कभी भी कच्चे क्रेडेंशियल नहीं देखते हैं - वे रनटाइम द्वारा इंजेक्ट किए गए पूर्व-प्रमाणीकृत टूल इंस्टेंस के साथ इंटरैक्ट करते हैं।

क्या एक एजेंट के पास कितने कौशल हो सकते हैं इसकी कोई सीमा है?

कौशल रजिस्ट्री की कोई सख्त सीमा नहीं है, लेकिन यदि आप ओवरलैपिंग विवरण के साथ सैकड़ों कौशल पंजीकृत करते हैं तो व्यावहारिक ऑर्केस्ट्रेशन गुणवत्ता में गिरावट आती है। संबंधित कौशलों को कौशल पैकेजों में समूहित करें, और स्पष्ट, विशिष्ट विवरण का उपयोग करें। बहुत बड़े कौशल पुस्तकालयों के लिए, विशेष एजेंटों में विभाजित होने और कार्यों को सही एजेंट तक पहुंचाने के लिए मल्टी-एजेंट ऑर्केस्ट्रेशन का उपयोग करने पर विचार करें।

क्या OpenClaw एजेंट क्लाउड निर्भरता के बिना ऑन-प्रिमाइसेस चला सकते हैं?

हाँ। ओपनक्ला क्लाउड-अज्ञेयवादी है। रनटाइम, मेमोरी बैकएंड और टूल लेयर सभी को ऑन-प्रिमाइस इंफ्रास्ट्रक्चर का उपयोग करने के लिए कॉन्फ़िगर किया जा सकता है। रेडिस स्थानीय रूप से चल सकता है, दीर्घकालिक मेमोरी बैकएंड ऑन-प्रिमाइस पोस्टग्रेएसक्यूएल उदाहरण को इंगित कर सकता है, और टूल एकीकरण आंतरिक एपीआई को लक्षित कर सकता है। ऑर्केस्ट्रेटर तर्क के लिए एलएलएम प्रदाता को एकमात्र बाहरी कॉल है - यदि आवश्यक हो तो आप इसे ऑन-प्रिमाइसेस एलएलएम का उपयोग करने के लिए कॉन्फ़िगर कर सकते हैं।

आप चल रहे कार्यों को बाधित किए बिना एजेंट कौशल का संस्करण कैसे बनाते हैं?

कौशलों को एजेंट मैनिफेस्ट में सिमेंटिक वर्जनिंग के साथ संस्करणित किया जाता है। रनटाइम रोलिंग परिनियोजन के दौरान एक साथ कई कौशल संस्करण चलाने का समर्थन करता है। इन-फ़्लाइट कार्य उसी कौशल संस्करण का उपयोग जारी रखते हैं जिसके साथ उन्होंने शुरुआत की थी; नए कार्यों के लिए नवीनतम संस्करण चुनें। कौशल इनपुट/आउटपुट स्कीमा में परिवर्तन को तोड़ने के लिए उस कौशल के आउटपुट का उपभोग करने वाले किसी भी एजेंट के लिए एक प्रमुख संस्करण बम्प और माइग्रेशन योजना की आवश्यकता होती है।

---

अगले चरण

उत्पादन-ग्रेड एआई एजेंटों के निर्माण के लिए अच्छे कोड से अधिक की आवश्यकता होती है - इसके लिए विफलता मोड, स्केलिंग पैटर्न और डोमेन-विशिष्ट कौशल पुस्तकालयों के साथ परिचालन अनुभव की आवश्यकता होती है, जिन्हें विकसित करने और परिष्कृत करने में महीनों लगते हैं।

ECOSIRE की ओपनक्लाव कस्टम स्किल्स सेवा एंड-टू-एंड एजेंट विकास प्रदान करती है: आवश्यकताओं का विश्लेषण, कौशल वास्तुकला, आपके मौजूदा सिस्टम के साथ एकीकरण, परीक्षण, तैनाती और चल रहे अनुकूलन। हमारी टीम ने दस्तावेज़ प्रसंस्करण, ईआरपी स्वचालन, ग्राहक सहायता, वित्तीय विश्लेषण और बहुत कुछ के लिए ओपनक्लॉ एजेंट बनाए हैं।

अपनी स्वचालन आवश्यकताओं पर चर्चा करने और एक कस्टम विकास रोडमैप प्राप्त करने के लिए किसी ओपनक्लॉ विशेषज्ञ से बात करें।