Agenty is a SaaS platform with easy-to-use automated cloud-based agents for data scraping, text extraction, text classification, OCR, categorization, change tracking, sentiment analysis and more to help businesses in converting the unstructured data into structured spreadsheet and machine readable data with no coding required

Agenty

In the dynamic landscape of cloud-deployed container workloads, the need for comprehensive performance monitoring to attain granular insights has never been more crucial. Facilitating monitoring capabilities to observe the underlying complex components, and extracting vital real-time insights through metrics and traces, is an absolute requirement for . Kubernetes A cloud-native approach to determine the specifics of each system event, encompassing the capacity to thoroughly monitor and analyze the operational dynamics and efficiency of Kubernetes clusters is an effective way to control the whole network. Kubernetes observability through metrics and traces bridges the gap by enabling you to collect and analyze operational data, guaranteeing the best performance, stability, and scalability. Activation of system-wide metrics and traces promotes with informed troubleshooting, offering an opportunity for performance optimization and increased system reliability. Kubernetes observability Metrics Kubernetes logs a broad spectrum of metrics by default, offering spontaneous information concerning the performance and behavior of cluster components. encompass crucial aspects like networking behavior, pods and node health, resource utilization, and overall application performance. These metrics can act as a gateway to gain a detailed understanding of the overall condition of operational clusters to avoid spot bottlenecks and enable efficient resource allocation. Logs Although there are third-party services to enable Kubernetes metrics, let's see how to facilitate the metrics using the metrics server. The Metrics Server is a Kubernetes component that collects resource consumption measurements from pods and nodes and exposes them for access through Kubernetes API. Metrics Server Deployment kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml Optionally, you can verify the deployment of the metrics server. kubectl get pods -n kube-system | grep metrics-server Traces Interpreting requests end-to-end flow for finding overall latency challenges and anomaly detection of the service is attained by enabling Traces. Distributed tracing presents component interaction insights, assisting in performance bottleneck identification and streamlined . troubleshooting Integrating with a tracing system like Jaeger or Zipkin is often required to enable distributed tracing in Kubernetes. Let's understand how to enable tracing using the commonly used tracing system, Jaeger. apiVersion: v1 kind: Namespace metadata: name: kubernetes-tracing -- apiVersion: apps/v1 kind: DaemonSet metadata: name: 
kubernetes-metrics namespace: kubernetes-tracing spec: selector: matchLabels: app: jaeger component: agent template: 
metadata: labels: app: jaeger component: agent spec: containers:name: kubernetes-metrics-jaeger-agent
image: jaegertracing/jaeger-agent:latest
ports: containerPort: 5775
protocol: UDP
ontainerPort: 5778 protocol: TCP` Agent Deployment kubectl apply -f jaeger-agent.yaml Verify the deployment by accessing the Jaeger UI. kubectl port-forward svc/<jaeger-ui-service-name>-n <namespace> <local-port>:<service-port> The Upside of Implementing Kubernetes Metrics and Traces for Augmented Insights Strategic implementation of advanced monitoring techniques yields an array of advantages as highlighted, concerning the performance and behavior of Kubernetes environments. : Traces enable the detection of resource-hungry components responsible for inefficiencies, while metrics provide admins with insights to allocate resources based on utilization patterns. Efficient Resource Management : Traces unveil room for optimizations by providing profound insights about latency and bottlenecks, while metrics offer resource and application activity monitoring to apply optimizations on-the-fly. Optimized Performance : Traces reveal the auto-scaling effect on the speed and latency of requests, while metrics help decipher how applications behave under heavy load. Scalability Insights : Traces and metrics provide insights into unusual patterns to detect anomalies that may pose security threats leading to breaches, bolstering the total security posture of the Kubernetes environments. Security Boost The Downside of Not Using Kubernetes Metrics and Traces In the absence of Metrics and trace enablement, the state of cluster and application behavior remains a mystery to the teams, forcing them to deal with the problems only after they impact users or interfere with business operations. Also, missing metrics and traces result in a lack of data on resource usage, preventing effective allocation and sparking performance degradation with undetected bottlenecks and difficulty in diagnosis. Best Practices for Enabling Kubernetes Insights Best practice adherence aids security and DevOps teams avoid the most frequently made mistakes, advancing them towards improved Kubernetes observability. Consistent Labeling To ensure efficient aggregation and querying of metrics, uniform, and meaningful labels are significant. Focusing on indicators that have a direct impact, organizations can effectively manage resources and react quickly to deviation from expected behavior. Centralized Alerting Mechanism Sound and robust alerting system implementation to react based on thresholds and anomalies to maintain the health and resistance of production-grade systems. By only focusing on environment-specific alerts, organizations can promote a quick resolution to incidents and enable a secure user experience with increased system reliability. eBPF Probes for Optimal Kernel-Level Observability Organizations can acquire unprecedented insight into the inner workings of the kernel, applications, and network interactions of Kubernetes components by mindfully deploying eBPF probes. eBPF probes facilitate the collection of accurate information without overloading the monitoring infrastructure. Conclusion Despite the reliability promise of cloud-native services, a cautious and robust strategy is a must due to the unknowns of distributed cloud components, especially Kubernetes, that could end up in a chaotic production environment if not managed elegantly. Kubernetes observability is an eccentric technique that makes it possible to rigorously capture, and examine operational data via metrics and traces. By enabling system-wide metrics and traces, Kubernetes observability paves an informed approach to troubleshooting and optimizing the infrastructure, leading to enhanced system reliability.

How Metrics and Traces Power Kubernetes Insights

Authors:
(1) Renato P. dos Santos, CIAGE – Centre for Generative Artificial Intelligence in Cognition and Education. Table of Links Abstract and Introduction Materials And Methods Results and Analyses Prompts and generated texts Conceptualizing chemical reactions Deepening on understanding of chemical reactions Question about combustion Question about a graph of gases turning into water over time Question about the difference between atoms, molecules, and moles Deepening on the concept of mole Question about changing of state Question about an animated representation of water molecules undergoing phase changes Question about plasma, a state of matter Question about chemical bondings Question about illustration of chemical bonds Question about the essence of the type of chemical bonding Further analysis Conclusions Limitations of the study and possible future studies Author Contributions, Conflicts of interest, Acknowledgements, and References Abstract This research delves into the comparative advantages of Generative AI chatbots (GenAIbots) - ChatGPT, Bing Chat, Bard, and Claude - in the context of Chemistry education, framed within a constructivist perspective. Our primary objective was to identify which of these four AI tools is more effective for enhancing Chemistry learning. Employing a single-case study approach, we scrutinised interaction logs between the AI systems and a simulated student persona during Chemistry learning simulations, incorporating Content Analysis methodology to delve deeper into the discourse. Our findings underscore these tools' potential as "agents-to-think-with", enhancing critical thinking, problem-solving, comprehension, creativity, and tailored learning. Especially noteworthy is their ability to stimulate learners through Socratic-like questioning, aligning with constructionist principles. The research emphasises the pivotal role of prompt crafting to coax desired responses from GenAIbots, engendering iterative reflections. It also highlights the need for robust educator training to infuse these technologies into educational settings. Conclusively, while ChatGPT, Bing Chat, Bard, and Claude are poised to enrich Chemistry education by fostering dynamic, inclusive learning experiences, ChatGPT stood out, decisively surpassing Bing Chat's performance. Bard and Claude trailed closely, with all three showcasing a more in-depth, precise, and nuanced understanding, underscoring ChatGPT's adeptness at contextual comprehension. Keywords: Chemistry education, ChatGPT, Bing Chat, Bard, Claude, Artificial Intelligence in Education, agents-to-think-with Introduction Chemistry, a core Science Education subject, clarifies matter's properties and transformations, thus critically shaping our daily lives (Dunlop et al., 2020). However, Chemistry is also a complex and dynamic field that necessitates a profound grasp of fundamental concepts and principles, and it is sometimes difficult for students to associate real-life circumstances with abstract chemistry concepts (Dewi et al., 2021). Research in Chemistry Education seeks effective strategies to alleviate these learning difficulties (Permatasari et al., 2022; Timilsena et al., 2022; Tümay, 2016). Timilsena et al. (2022) identified difficulties in understanding the abstract nature of chemical reactions and factors such as inadequate teaching materials and curriculum complexity, emphasising the need for effective teaching strategies and tools. Tümay (2016) discussed students' struggles in understanding fundamental chemistry concepts and emphasised the importance of addressing misconceptions and learning difficulties. Dewi et al. (2021) underscored the need for critical thinking skills and the integration of digital technology to enhance the quality of Chemistry education for Generation Z students. Dunlop et al. (2020) proposed introducing philosophical dialogue in higher education to address undergraduate Chemistry students' challenges, suggesting that it can stimulate new ways of thinking. In 2023, Castro Nascimento and Pimentel undertook a study to evaluate the proficiency of the ChatGPT model by having it respond to five distinct tasks across various subfields of chemistry (Castro Nascimento & Pimentel, 2023). These tasks included converting compound names to their SMILES chemical representation and vice versa, procuring information on the octanol-water partition coefficient of chemical compounds, extracting structural information on coordination compounds, determining the water solubility of polymers, and identifying the molecular point groups of simple molecular compounds. The unsatisfactory outcomes highlighted potential limitations in the model's ability to adequately address these specific chemistry-related queries. Notably, the suboptimal performance observed might be attributed to utilising an antiquated version of ChatGPT, specifically the GPT-3 model introduced by OpenAI in 2020 (Brown et al., 2020). In a separate study conducted in the same year, Leon and Vidhani (2023) explored the reliability of ChatGPT responses within the framework of an introductory college-level Chemistry course. Their findings indicated a significant reliability concern, with ChatGPT failing to secure a score above 37%. Such a performance implies that learners relying on this tool for study support would predominantly receive incorrect responses, with the variability of the tool leading to different responses for individual learners. Although the authors didn't specify which version of ChatGPT they utilised in their study, their reference to "ChatGPT's free original version" and the citation of Floridi and Chiriatti's (2020) research on ChatGPT-3 hint at the likelihood that they employed this version. Additionally, Pimentel et al. (2023) delved into the efficacy of ChatGPT versions 3 and 4 in responding to intricate questions spanning six topics in Chemistry. While they concluded that both versions were currently inadequate in addressing the nuances of complex topics, they also observed noteworthy advancements from ChatGPT-3 to ChatGPT-4. Such progress signals promising potential for the tool to aid scientists in future literature reviews, surveys, and educational endeavours. Generative AI-powered chatbots (GenAIbots), including ChatGPT, Bing Chat, Bard, and Claude, have been introduced as innovative solutions to persistent challenges in Chemistry education (Baidoo-Anu & Owusu Ansah, 2023; Taylor et al., 2022). Their emergence offers a dynamic, inclusive educational environment, transforming how complex concepts are conveyed and understood. These GenAIbots simplify intricate topics, promote self-reflection, engage users in stimulating dialogues, facilitate personalised learning, and enhance critical thinking, collaboration, and cognitive development (Okonkwo & Ade-Ibijola, 2021). As a result, they have played a pivotal role in revolutionising Chemistry education. In the discourse on agency, traditional theories, such as the ones of Anscombe and Davidson, attribute actions to entities based on representational mental states encompassing desires, beliefs, and intentions. However, alternative perspectives, drawing from the works of Heider and Simmel, Dennett, Davidson, and Barandiaran et al., challenge this representation dependent view, suggesting potential agency without such mental representations (Schlosser, 2019). When considering GenAIbots within these frameworks, the entity's ability to respond based on training contrasts with its lack of self-awareness, intentions, and proactive behaviour— characteristics central to the agency. Consequently, while dominant philosophical and cognitive models would not grant ChatGPT agency, more expansive interpretations, as offered by these cited thinkers, could accept it. Building on this foundation and inspired by Melanie Swan's suggestion, we have expanded upon Papert's (1980) concept of "objects-to-think-with" to introduce “agents-to-thinkwith.” This positions GenAIbots as integral participants in the educational path, echoing Turkle's (1984) concept of "metacognitive machines," in the sense that they assist in enhancing one's awareness of their own cognitive processes, i.e., "thinking about thinking" as described by Flavell (1976). In Latour's (1991) perspective, we can perceive GenAIbots as "hybrids," which blur the boundaries between humans and non-human entities. Such a perspective further aligns with Swan's (2015) vision of a future where augmented humans and AI collaborate and thrive symbiotically. While GenAIbots posit themselves as powerful metacognitive educational tools, promoting critical thinking, problem-solving, and deep comprehension of concepts, it's imperative to acknowledge their limitations. For instance, there's the possibility of generating nonsensical or inaccurate content, as OpenAI (2023) highlighted. Nevertheless, the unique ability of GenAIbots to provide instant feedback, introduce diverse perspectives, and foster an interactive engagement with complex ideas solidifies their position as influential agents-to-think-with in the realm of Chemistry education. This paper is available on arxiv under CC BY-SA 4.0 DEED license. Authors: (1) Renato P. dos Santos, CIAGE – Centre for Generative Artificial Intelligence in Cognition and Education. Authors: Authors: (1) Renato P. dos Santos, CIAGE – Centre for Generative Artificial Intelligence in Cognition and Education. Table of Links Abstract and Introduction Abstract and Introduction Materials And Methods Materials And Methods Results and Analyses Results and Analyses Prompts and generated texts Prompts and generated texts Conceptualizing chemical reactions Conceptualizing chemical reactions Deepening on understanding of chemical reactions Deepening on understanding of chemical reactions Question about combustion Question about combustion Question about a graph of gases turning into water over time Question about a graph of gases turning into water over time Question about the difference between atoms, molecules, and moles Question about the difference between atoms, molecules, and moles Deepening on the concept of mole Deepening on the concept of mole Question about changing of state Question about changing of state Question about an animated representation of water molecules undergoing phase changes Question about an animated representation of water molecules undergoing phase changes Question about plasma, a state of matter Question about plasma, a state of matter Question about chemical bondings Question about chemical bondings Question about illustration of chemical bonds Question about illustration of chemical bonds Question about the essence of the type of chemical bonding Question about the essence of the type of chemical bonding Further analysis Further analysis Conclusions Conclusions Limitations of the study and possible future studies Limitations of the study and possible future studies Author Contributions, Conflicts of interest, Acknowledgements, and References Author Contributions, Conflicts of interest, Acknowledgements, and References Abstract This research delves into the comparative advantages of Generative AI chatbots (GenAIbots) - ChatGPT, Bing Chat, Bard, and Claude - in the context of Chemistry education, framed within a constructivist perspective. Our primary objective was to identify which of these four AI tools is more effective for enhancing Chemistry learning. Employing a single-case study approach, we scrutinised interaction logs between the AI systems and a simulated student persona during Chemistry learning simulations, incorporating Content Analysis methodology to delve deeper into the discourse. Our findings underscore these tools' potential as "agents-to-think-with", enhancing critical thinking, problem-solving, comprehension, creativity, and tailored learning. Especially noteworthy is their ability to stimulate learners through Socratic-like questioning, aligning with constructionist principles. The research emphasises the pivotal role of prompt crafting to coax desired responses from GenAIbots, engendering iterative reflections. It also highlights the need for robust educator training to infuse these technologies into educational settings. Conclusively, while ChatGPT, Bing Chat, Bard, and Claude are poised to enrich Chemistry education by fostering dynamic, inclusive learning experiences, ChatGPT stood out, decisively surpassing Bing Chat's performance. Bard and Claude trailed closely, with all three showcasing a more in-depth, precise, and nuanced understanding, underscoring ChatGPT's adeptness at contextual comprehension. Keywords: Chemistry education, ChatGPT, Bing Chat, Bard, Claude, Artificial Intelligence in Education, agents-to-think-with Keywords: Introduction Chemistry, a core Science Education subject, clarifies matter's properties and transformations, thus critically shaping our daily lives (Dunlop et al., 2020). However, Chemistry is also a complex and dynamic field that necessitates a profound grasp of fundamental concepts and principles, and it is sometimes difficult for students to associate real-life circumstances with abstract chemistry concepts (Dewi et al., 2021). Research in Chemistry Education seeks effective strategies to alleviate these learning difficulties (Permatasari et al., 2022; Timilsena et al., 2022; Tümay, 2016). Timilsena et al. (2022) identified difficulties in understanding the abstract nature of chemical reactions and factors such as inadequate teaching materials and curriculum complexity, emphasising the need for effective teaching strategies and tools. Tümay (2016) discussed students' struggles in understanding fundamental chemistry concepts and emphasised the importance of addressing misconceptions and learning difficulties. Dewi et al. (2021) underscored the need for critical thinking skills and the integration of digital technology to enhance the quality of Chemistry education for Generation Z students. Dunlop et al. (2020) proposed introducing philosophical dialogue in higher education to address undergraduate Chemistry students' challenges, suggesting that it can stimulate new ways of thinking. In 2023, Castro Nascimento and Pimentel undertook a study to evaluate the proficiency of the ChatGPT model by having it respond to five distinct tasks across various subfields of chemistry (Castro Nascimento & Pimentel, 2023). These tasks included converting compound names to their SMILES chemical representation and vice versa, procuring information on the octanol-water partition coefficient of chemical compounds, extracting structural information on coordination compounds, determining the water solubility of polymers, and identifying the molecular point groups of simple molecular compounds. The unsatisfactory outcomes highlighted potential limitations in the model's ability to adequately address these specific chemistry-related queries. Notably, the suboptimal performance observed might be attributed to utilising an antiquated version of ChatGPT, specifically the GPT-3 model introduced by OpenAI in 2020 (Brown et al., 2020). In a separate study conducted in the same year, Leon and Vidhani (2023) explored the reliability of ChatGPT responses within the framework of an introductory college-level Chemistry course. Their findings indicated a significant reliability concern, with ChatGPT failing to secure a score above 37%. Such a performance implies that learners relying on this tool for study support would predominantly receive incorrect responses, with the variability of the tool leading to different responses for individual learners. Although the authors didn't specify which version of ChatGPT they utilised in their study, their reference to "ChatGPT's free original version" and the citation of Floridi and Chiriatti's (2020) research on ChatGPT-3 hint at the likelihood that they employed this version. Additionally, Pimentel et al. (2023) delved into the efficacy of ChatGPT versions 3 and 4 in responding to intricate questions spanning six topics in Chemistry. While they concluded that both versions were currently inadequate in addressing the nuances of complex topics, they also observed noteworthy advancements from ChatGPT-3 to ChatGPT-4. Such progress signals promising potential for the tool to aid scientists in future literature reviews, surveys, and educational endeavours. Generative AI-powered chatbots (GenAIbots), including ChatGPT, Bing Chat, Bard, and Claude, have been introduced as innovative solutions to persistent challenges in Chemistry education (Baidoo-Anu & Owusu Ansah, 2023; Taylor et al., 2022). Their emergence offers a dynamic, inclusive educational environment, transforming how complex concepts are conveyed and understood. These GenAIbots simplify intricate topics, promote self-reflection, engage users in stimulating dialogues, facilitate personalised learning, and enhance critical thinking, collaboration, and cognitive development (Okonkwo & Ade-Ibijola, 2021). As a result, they have played a pivotal role in revolutionising Chemistry education. In the discourse on agency, traditional theories, such as the ones of Anscombe and Davidson, attribute actions to entities based on representational mental states encompassing desires, beliefs, and intentions. However, alternative perspectives, drawing from the works of Heider and Simmel, Dennett, Davidson, and Barandiaran et al., challenge this representation dependent view, suggesting potential agency without such mental representations (Schlosser, 2019). When considering GenAIbots within these frameworks, the entity's ability to respond based on training contrasts with its lack of self-awareness, intentions, and proactive behaviour— characteristics central to the agency. Consequently, while dominant philosophical and cognitive models would not grant ChatGPT agency, more expansive interpretations, as offered by these cited thinkers, could accept it. Building on this foundation and inspired by Melanie Swan's suggestion, we have expanded upon Papert's (1980) concept of "objects-to-think-with" to introduce “agents-to-thinkwith.” This positions GenAIbots as integral participants in the educational path, echoing Turkle's (1984) concept of "metacognitive machines," in the sense that they assist in enhancing one's awareness of their own cognitive processes, i.e., "thinking about thinking" as described by Flavell (1976). In Latour's (1991) perspective, we can perceive GenAIbots as "hybrids," which blur the boundaries between humans and non-human entities. Such a perspective further aligns with Swan's (2015) vision of a future where augmented humans and AI collaborate and thrive symbiotically. While GenAIbots posit themselves as powerful metacognitive educational tools, promoting critical thinking, problem-solving, and deep comprehension of concepts, it's imperative to acknowledge their limitations. For instance, there's the possibility of generating nonsensical or inaccurate content, as OpenAI (2023) highlighted. Nevertheless, the unique ability of GenAIbots to provide instant feedback, introduce diverse perspectives, and foster an interactive engagement with complex ideas solidifies their position as influential agents-to-think-with in the realm of Chemistry education. This paper is available on arxiv under CC BY-SA 4.0 DEED license. This paper is available on arxiv under CC BY-SA 4.0 DEED license. available on arxiv

Enhancing Chemistry Learning with ChatGPT, Bing Chat, Bard, and Claude as Agents-to-Think-With

ChatGPT, Bing Chat, Bard, এবং Claude-এর সাথে এজেন্ট-টু-থিঙ্ক-এর মাধ্যমে রসায়ন শেখার উন্নতি করা

Verbesserung des Chemielernens mit ChatGPT, Bing Chat, Bard und Claude als Denkagenten

Mejora del aprendizaje de química con ChatGPT, Bing Chat, Bard y Claude como agentes con los que pensar

Améliorer l'apprentissage de la chimie avec ChatGPT, Bing Chat, Bard et Claude en tant qu'agents avec lesquels penser

चैटजीपीटी, बिंग चैट, बार्ड और क्लाउड के साथ रसायन विज्ञान सीखने को बेहतर बनाना, एजेंट-टू-थिंक-विथ

ChatGPT、Bing Chat、Bard、Claude をエージェントとして利用して化学学習を強化する

ChatGPT, Bing Chat, Bard 및 Claude를 생각하는 에이전트로 사용하여 화학 학습 강화

Aprimorando o aprendizado de química com ChatGPT, Bing Chat, Bard e Claude como agentes para pensar

Улучшение изучения химии с помощью ChatGPT, Bing Chat, Bard и Claude в качестве агентов для размышлений

Birlikte Düşünülecek Aracılar Olarak ChatGPT, Bing Chat, Bard ve Claude ile Kimya Öğrenimini Geliştirme

Nâng cao việc học hóa học với ChatGPT, Bing Chat, Bard và Claude với tư cách là Đại lý để suy nghĩ

使用 ChatGPT、Bing Chat、Bard 和 Claude 作为思考代理来增强化学学习

NEW YORK, New York, March 26th, 2024/Chainwire/--**Syntax takes natural language and converts it into Solidity code, enabling individuals and enterprises to ship production grade smart contracts, arbitrage agents, NFTs, rollups, and more. Syntax marks the manifestation of the Agent Economy in Web3. Today, has launched Syntax, a new LLM enabling people to ship agents that automate onchain projects and tasks, thereby manifesting their Web3 product ideas. While still in beta, Syntax’s vision is to create an open onchain Agent Economy, where developers, individuals, and enterprises can for the first time select the agents they would want to delegate their Web3 tasks, projects, and product development to. These projects and products include production grade smart contracts, arbitrage agents, NFTs, rollups, and more. Spectral Labs Scaling web3 engineering efforts and shipping new onchain products is limited by the number of solidity developers, as well as enterprises’ ability to test and ship smart contract code in a fast and effective way without burning through engineering resources. Spectral has set out to solve this with its new LLM, Syntax, a development environment designed to manifest Web3 product ideas by converting natural language into Solidity code that can be deployed instantly onchain. For professional developers, Syntax can accelerate and optimize bandwidth by writing large libraries and components. Syntax provides an Agentic experience, where users tell Syntax what they want to build, and Syntax writes and deploys the code onchain at the click of a button. Spectral defines an Onchain Agent as a set of instructions and code capable of deploying itself onchain and possessing a dedicated provisioned wallet for doing so. Loosely similar to custom instructions in ChatGPT, Syntax Agents also have their own identity and can autonomously figure out ways to interact with deployment infrastructure. With Syntax, users can compile, debug, and deploy AI-generated solidity code. Syntax gives users and the industry the ability to quickly test, ship and scale new products, as well as determining the usability and functional relevance of the code generated while also giving them control to quickly edit code snippets. Initially, Spectral’s Onchain Agents will be curated and built by Spectral, but soon every user will be able to create their own Agent and monetize it in future Syntax releases. "At Spectral, we're pioneering a future where autonomous Agents redefine what's possible onchain. With Spectral Syntax, we empower these agents to operate independently, making it simpler for everyone to bring their blockchain ideas to life." Sishir Varghese, Founder. What truly sets Syntax apart is its capability to deploy code directly onchain, executing deployments through Foundry by writing instructions that Foundry can process, including code compilation, onchain deployment, and signing transactions. Syntax is pioneering an accessible onchain Agent Economy, inviting users to select agents tailored for their specific Web3 tasks. Users can either interact with the foundational agent or opt for one of the specialized agents, each adept in distinct tasks and operations—like the Code Forker assistant, ideal for those aiming to fork and customize a codebase. Additionally, users can discern an agent's expertise and trustworthiness by reviewing its category listing and the popularity reflected through its user engagement. "Syntax by Spectral is at the forefront of merging AI with web3, pioneering the onchain agent economy and making it easier and more accessible for users to create their own blockchain products," said Josh Rosenthal, Partner, Polychain Syntax produces accurate and gas-optimized Solidity code for a variety of prompts ranging from low to medium complexity, and it outperforms baseline models on Spectral’s Solidity evaluation dataset. As Spectral’s modeling efforts continue to evolve, the company expects Syntax to deliver optimized code for increasingly complex problems. These Solidity models are explicitly designed to assist developers in writing optimized, modern, well-tested, and secure code. About Spectral , a pioneer of the agent economy behind Syntax, is at the forefront of integrating AI with blockchain to democratize development in Web3. Our mission is to simplify the creation and deployment of decentralized applications through autonomous Onchain Agents. Syntax, Spectral’s flagship product, translates natural language into Solidity code, enabling both novices and experts to build on the blockchain effortlessly. Spectral With a commitment to transparency and user empowerment, Spectral is shaping a future where anyone can participate in the blockchain revolution. Join us in making this vision a reality and explore the potential of autonomous agents with Spectral. For more information, visit /. For more information, users can follow Spectral on and . https://spectrallabs.xyz Twitter Discord Contact Spectral Labs Spectral info@spectrallabs.xyz This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here.

Spectral Launches Syntax Enabling Web3 Users To Build Autonomous Agents And Deploy Onchain Products

is a distributed unit of infrastructure. It can provide information about FreeBSD and Linux operating systems. It also supports metrics transmission to Clickhouse, InfluxDB, and Prometheus. Alligator The main interface of alligator is . It connects with spreading Prometheus as a monitoring system in many infrastructures. However, the Prometheus ecosystem has some problems. OpenMetrics First of all - the specialized and simplified agents. Every service on the host needs a specialized exporter. This is the reason for having a lot of exporters per host (like a node_exporter, redis_exporter, sentinel_exporter, and so on). Secondly, simplified agents. A lot of agents can be used for different tasks (like an SNMP, blackbox, etc.), and it inflates infrastructure for such daemons to collect information. Sometimes, a pull model has problems with multi-worker applications and cron jobs - nothing can give metrics from hosts when Prometheus makes a request, or it is connected with problems related to synchronizing results between workers. It forces us to use statsd/pushgateway. Then the question comes up: how to remove outdated metrics? How to make it a high-availability service? The approach of the alligator is different - it is a smart agent for the Prometheus. Alligator consists of a system exporter and an application exporter. It also provides a push model for pushgateway, statsd, and graphite emulation protocol. Metrics Export Alligator supports such sets of metrics: FreeBSD and GNU/Linux system metrics. Filesystem metrics (file’s checksum, sizes, and access level). Certificate metrics (PEM and P12). Some popular applications (ElasticSearch, uwsgi, Druid, RabbitMQ, and others). Ephemeral metrics. It supports pushgateway, statsd, and graphite protocol, and it can collect metrics from file on FS. It also has a cluster mode for centralized installation of pushgateway. Simple JSON to metrics parser. Simple HTTP/TCP checker. Use Cases A part of supported technologies for collecting metrics are reviewed in the . The rest I am describing here. official documentation Application Server Metrics First of all, alligator can collect application server metrics. For instance, alligator can gather metrics from uwsgi instances with this configuration: aggregate {
    uwsgi tcp://localhost:1717;
} and rerun the uwsgi server with the : expose stats port --stats 127.0.0.1:1717 Another example, fastcgi-application: aggregate {
    php-fpm fastcgi://127.0.0.1:9000/stats?json&full;
} and write this option in : php-fpm config pm.status_path = /stats After this, you will have common metrics from the application server. Application Metrics I recommend using synchronization structures to collect metrics in the application internally. Alternatively, you can make only 1 worker per instance and use such an abstraction as orchestration (Kubernetes, opennebula, and others). And next, use alligator as a push server for metrics. Alligator has many collectors to collect it: pushgateway prom-aggregation-gateway statsd graphite file These approaches ensure that metrics will be collected from all workers of the application Applications have to send metrics to alligator. To remove influence on one metric by different workers, you can use two different approaches: mark metric with the worker ID from prometheus_client import Counter, push_to_gateway, CollectorRegistry
    registry = CollectorRegistry()
    c = Counter('my_requests_total', 'HTTP Failures', ['method', 'worker_id'], registry=registry)
    c.labels(method='get', worker_id=uwsgi.worker_id()).inc()
    c.labels(method='post', worker_id=uwsgi.worker_id()).inc()
    push_to_gateway('localhost:1111', job='myapp', registry=registry) use instead of metric type if you can. File collector cannot calculate increment, but others can increment if the counter is a type of metric. You can only send increment value to alligator, and alligator will calculate the sum. Counter Gauge More information about the difference between metric types can be found or on the . here official page What Metrics Do I Recommend to Measure in Applications? Firstly, it is any outgoing requests to external systems. In worker applications, it often is the reason to overflow workers or cause of low speed of query processing. My recommended list of metrics: count of requests to external services grouped by request types request time from external services (avg, or if possible, by quantiles/buckets of time) grouped by request types status of requests grouped by request type (success or errors) It would be nice if you could group not only by request type but more by network layer of requests: DNS resolve count, time, and status connect count, time, and status write/read count, time, and status It is also important to measure internal application metrics: ingoing requests grouped by types processing ingoing request time avg (quantile or buckets if possible) by type status of ingoing request by type cache status (hit/miss if it exists) I guess you can make another list of metrics, but these metrics are the most important to reveal problems and give main observability about application health. If your application is working in podman or docker environment, you can expose the container statistics. Alligator mechanics are similar to Cadvisor's when collecting container statistics. To enable, you have to use option cadvisor in the system context: Container checks. system {
    cadvisor;
} . This is a good way to monitor applications or external sources for reliability. Let’s check the resources on two ports every minute: Blackbox checks aggregate_period 60;
aggregate {
    blackbox http://127.0.0.1:80/check;
    blackbox https://127.0.0.1:443/check;
} Alligator produces network and application response metrics for this resource (response code, response time, and certificate expiration date). If the application has a page with JSON, alligator can also convert JSON to metrics: aggregate {
    jsonparse https://jsonplaceholder.typicode.com/todos;
} The next level of blackbox metrics - checking the process, service, and listening port: system {
	services uwsgi.service;
	process uwsgi;
}


query {
	expr 'count by (src_port, process) (socket_stat{process="uwsgi", src_port="80"})';
	make socket_match;
	datasource internal;
} And in the end: launching external programs and proactive actions (like watchdog): aggregate {
	process 'exec:///usr/local/bin/mycheckscript.sh';
} If the script can produce a metric that can determine the exact application downtime, this metric can be used for proactively restart: query {
    expr 'myapplication_status < 1';
    make app_is_down;
    datasource internal;
    action app_is_down;
}
action {
    name app_is_down;
    type shell;
    expr 'exec://systemctl restart uwsgi;
    datasource internal;
} System Metrics Any application metrics are also important. But without system metrics of servers, you won’t be able to clearly understand what happens in your system. System metrics are a set of metrics that help us gain insight into the health of our systems. This is the basis for making decisions if something goes wrong. An alligator with an empty configuration doesn’t collect any metrics at all. Any system metrics are classified into the following categories: base - CPU, memory, time, logical resources, and other common metrics about the server disk - disk usage and I/O network - interface statistics, network counters, sockets statistics smart - collecting S.M.A.R.T. statistics cpuavg - analog for load average when alligator make by CPU-only load firewall - counters from the system firewall process - check process (uptime, ulimits usage, status, CPU, memory, and disk consumption) packages - metrics with a list of installed packets in the system services - systemd services stats This is configured in a block called “system” in alligator.conf: system {
    base;
    disk;
    network;
    process;
    cpuavg period=5;
} What about cron jobs? How can it be connected to the Prometheus via alligator? There are several ways to do this. The simple way is to output metrics to a file: aggregate {
    prometheus_metrics file:///var/lib/stats/metrics.txt state=save;
} The parameter called ‘state’ enables autosaving at a point of the file when alligator is stopped. It makes us sure that we can stop the alligator and run again, and it rereads only that part of the file that has not been read yet. If we want to reread a file from the start (every 10 sec), we have to use . The third way - is to read only realtime data. To enable this mode, we have to remove any state from the configuration file. state=begin The other way is to use statsd or extended pushgateway protocol (called prom-aggregation-gateway): It only needs to have this section in the configuration: entrypoint {
	tcp 1111;
    metric_aggregation count;
} For instance, we have a code: #!/bin/sh
TASKS=0
do_something() {
        echo 0
        TASKS=$1
}

res=`do_something 1`
echo "amount_of_done_tasks {method=\"do_something\", status=\"done\"} $TASKS
task_exit_code {method=\"do_something\"} $res" | curl --data-binary @- http://localhost:1111/ This script will make two metrics in alligator: amount_of_done_tasks {status="done", method="do_something"} 0.000000
task_exit_code {method="do_something"} 0.000000 Sometimes, we might get a situation when the script is not working, but the metric exists (because alligator doesn’t know that the application doesn't work). To solve this problem, alligator has TTL mechanics. You can specify the lifetime in seconds for a request: curl -H "X-Expire-Time: 30" --data "living_thirty_seconds_metric 4" http://localhost:1111/ Or in the configuration file: entrypoint {
    ttl 30;
    tcp 1111;
    metric_aggregation count;
} The next way is using statsd protocol (udp or tcp). TCP server for statsd is enabled by default. If you want to use udp, specify the UDP port in config: entrypoint {
        ttl 30;
        tcp 1111;
        udp 1111;
} And your job script might have a section like this: from statsd import StatsClient, TCPStatsClient
from time import sleep

statsd = StatsClient(host='localhost',
                     port=1111,
                     prefix=None,
                     ipv6=False)

statsd.incr('baz')
statsd.incr('baz') Graphite protocol is also supported by alligator, and it works like graphite_exporter. Internet Web Server If I have an internet web server, what options do I have? First of all, https is the most popular protocol for web servers today. It forces us to check the certificate expiration time: To check directories with certificates: x509
{
	name nginx;
	path /etc/nginx/ssl/;
	match .crt;
}
x509
{
	name letsencrypt;
	path /etc/letsencrypt/live;
	match .pem;
} Secondly, to check the nginx listening ports: query {
	expr 'count by (src_port, process) (socket_stat{process="nginx", src_port="80"})';
	make socket_match;
	datasource internal;
}
query {
	expr 'count by (src_port, process) (socket_stat{process="nginx", src_port="443"})';
	make socket_match;
	datasource internal;
} To check nginx -t to exclude the situation, when nginx after server reboot cannot be started: aggregate {
	process 'exec:///sbin/nginx -t';
} To check system, web-server process, and firewall counters system {
    base;
    disk;
    network;
    cpuavg period=5;
    services nginx.service;
    process nginx;
    firewall ipset=on;
} We also make alligator port accessible only on local interfaces: entrypoint {
    handler prometheus;
    allow 127.0.0.1;
    allow 10.0.0.0/8;
    allow 172.16.0.0/12;
    allow 192.168.0.0/16;
    tcp 1111;
} or you can use the notation tcp in the tcp directive. <localIP>:<port> Statsd Metric Mapping Simple statsd doesn’t work with labels. To create a label from a statsd metric name, you must use mapping with metric name templates to change new names and create new labels. Due to this, I recommend using an extended format of Statsd, like DogStatsd (alligator also supports this extension), which supports labels in statsd protocol. But, some programs have already made pure statsd protocol without labels. One such example is Airflow. You can catch metrics from Airflow like this: airflow.ti.finish.upload_job.load_data.success:1|c
airflow.ti.finish.upload_job.other_data.success:1|c where the name is the following template: airflow.ti.finish.<job name>.<process name>:<increment by>|type The mapping for such metric name can be: entrypoint {
    tcp 1111;
    udp 1111;
    mapping {
        template   airflow.ti.finish.*.*.*;
        label dag_id "$1;
        label task_id "$2";
        label state "$3";
        name airflow_ti_finish;
        match glob;
    }
} This mapping will create such a metric: airflow_ti_finish {state="success", dag_id="upload_job", task_id="load_data"} 1.000000
airflow_ti_finish {state="success", dag_id="upload_job", task_id="other_data"} 1.000000 Statsd or Pushgateway Cluster Firstly, you can only make some amount of servers statsd or pushgateway and simply proxying to them. The first problem with using this: if you want to use gauges, you will have problems with calculating. If there is a distributed application sending a metric with the same name and labels, the gauge metric will also be replaced by the application. The first way to fix this - is to specify different labels for each application (such as hostname and/or worker_id/process_id). But that is not all. You also have a problem with the same gauge metric: this metric can be a balancer on different machines. Here is what to do with a metric that was sent at different times, but now they are interfering with each other: 10:12 http_request_time_avg {appid="43"} 12
10:14 http_request_time_avg {appid="43"} 22
10:55 http_request_time_avg {appid="43"} 122
11:58 http_request_time_avg {appid="43"} 1232 You can use nginx upstreams with a balancing method called hash: upstream alligators {
    server srv1.example.com:1112;
    server srv2.example.com:1112;
    server srv3.example.com:1112;
    server srv4.example.com:1112;
    server srv5.example.com:1112;
    hash $remote_addr consistent;
} Then one backend will always push all metrics to one server. On the other hand - cluster mode in alligator. Let's set it up! Firstly, we allocated 3 ports: for getting metrics 1111 for replication works 1112 for getting metrics from other applications 80 Imagine that our server is listening to the internet. Then, we need to secure our push metric ports. We can use the directive “return” with arg “empty” to remove any answers outside. We also know that internet browsers don't send POST queries to other domains if CORS doesn't allow this. Thirdly, make an authentication for POST requests. entrypoint {
   allow 127.0.0.1;
   allow 10.0.0.0/8;
   tcp 1111;
}
entrypoint {
   allow 10.0.0.0/8;
   tcp 1112;
   cluster replication;
   instance srv1.example.com:1112;
}
entrypoint {
   return empty;
   allow 0.0.0.0/0;
   ttl 300;
   tcp 80;
   metric_aggregation count;
   auth basic user:setme;
   auth_header Authorization;
   header access-control-allow-headers 'Authorization';
   header access-control-allow-methods POST;
   header access-control-allow-origin *;
} That's good. We annotate that we have a cluster called “replication” and the current instance name. Since this moment, alligator allows to answer collected oplog to anyone from network 10.0.0.0/8 on port 1112. How to command an alligator to join other instances of cluster? For this, we will use the “cluster” directive. We can specify oplog size (the limit of in-memory stored metrics that will wait to sync to other instances), and distribute metrics by its metric name (sharding key in our case, but you can use any other label). The replication factor hides replicated metrics while another primary server is running in the cluster. If the primary server goes down, hidden metrics will be exposed and made available to Prometheus from other instances. cluster {
   name replication;
   size 10000;
   sharding_key __name__;
   replica_factor 2;
   type oplog;
   servers srv1.example.com:1112 srv2.example.com:1112 srv3.example.com:1112 srv4.example.com:1112 srv5.example.com:1112;
} Check the External Sites Status Blackbox mechanics for collecting information about network services have already been mentioned. Nevertheless, that is not all that alligator can be used for. Alligator also has a puppeteer parser for loading external pages with a lot of site resources (which can load a page DOM). puppeteer {
    https://site1.example.com;
    https://site2.example.com;
    https://example.com;
} They might measure domain lookup name in metric: puppeteer_domainLookupEnd - puppeteer_domainLookupStart Connect time: puppeteer_connectEnd - puppeteer_connectStart Time to load DOM: puppeteer_DomContentLoaded Status of loading: puppeteer_eventSourceResponseStatus And even errors in the browser console: puppeteer_eventConsole This is not all that a puppeteer collector can do. However, this engine needs nodejs to be installed on a machine with puppeteer dependencies. Install puppeteer dependency: cd /var/lib/alligator/
npm i puppeteer@14.3.0
npm i ps-node-promise-es6 Conclusion Monitoring systems is a really big challenge despite the amount of tools to solve it. You can choose between a monitoring system or tools in one system of monitoring (such as VictoriaMetrics, Thanos, some amount of exporters, and so on). I guess that the approaches outlined in the article can be applicable to any other tools of monitoring. Alligator is a tool that can simplify it. The main goal of any monitoring is to make your system observable. You must have all measured information from your systems to ensure that it always operates correctly.

Alligator Is a Prometheus Monitoring Agent: Everything You Need to Know About It

Large language models (LLMs), representing the new wave of cutting-edge generative AI, exhibit remarkable capabilities across a wide range of domains, from natural language processing to content generation. However, discussion around a persistent flaw has surfaced recently, plaguing developers and businesses alike—unsupported or illogical information, commonly called "hallucinations." To get around this, some AI application development teams are increasingly adopting Software as a Service (SaaS) tools that leverage the power of generative AI and adopting a human-in-the-loop workflow to achieve an increase in model accuracy. A recent study on the “ ” shed light on a straightforward trajectory for the incident response lifecycle. It underscores the importance of using a unified SaaS tool or platform that seamlessly integrates all incident management tools utilized by organizations. This tool should not only harness insights from human data but also leverage generative AI, enhancing operational efficiency and facilitating informed decision-making. State of DevOps Automation and AI In this piece, we will delve into the integration of human-in-the-loop (HITL) approaches within multi-agent AI systems to unlock the full potential of LLMs while mitigating their inherent limitations. The Vision of Multi-Agent LLMs We would love to get to a point where there is an AI ecosystem with various autonomous agents that complement each other's strengths, working in harmony with ongoing human involvement. The market suggests that hopefully we will reach this point soon. In 2023, the revenue of the worldwide ‘ ’ surpassed $4.8 billion, and it is anticipated to reach approximately $28.5 billion by 2028. Autonomous AI and Autonomous Agents Market The "human expert in the loop" model involves combining generative language models, logic-driven quality assurance systems, and specialist content models under human supervision. This selective combination ensures tailored solutions that contribute unique strengths toward a reliable and trustworthy output. The task characteristics of LLM-based AI automation agents introduce various nuances. Reading data is generally considered safer than writing data, which requires human-in-the-loop validation to avoid unintended consequences. As tasks become more complex, involving multiple agents or skills, aggregating their outputs becomes crucial for overall reliability and performance. However, the narrative expands beyond the individual capabilities of LLMs. The emergence of multi-agent LLMs signifies a leap forward in AI architecture. Structured as AI systems facilitating dynamic conversations between a collection of language models serving as the reasoning engine for AI agents, multi-agent LLMs offer a collaborative approach to problem-solving. Each agent possesses distinct strengths and weaknesses, akin to assembling a team with diverse expertise. Unlike traditional LLMs operating in isolation, multi-agent LLMs engage in natural language interactions with each other, autonomously working on complex tasks. The modular nature of this approach increases versatility, enabling developers to create reusable LLM components for custom applications. This adaptability makes multi-agent LLMs well-suited for intricate tasks like those in autonomous vehicles, supply chain management, or cyber risk detection and mitigation. Powerful Use Cases Unleashed by Multi-Agent LLMs The applications of multi-agent LLMs are far-reaching: Healthcare, Finance, and Education In the medical field, where accurate and timely information is critical, multi-agent LLMs provide on-demand expertise for diagnostics and treatment options, enhancing patient care. Financial institutions can leverage multi-agent LLMs to analyze market trends, assess investment strategies, and offer personalized financial advice, elevating services and customer satisfaction. Finally, multi-agent LLMs could transform education by providing students access to diverse subject matter experts, fostering personalized learning experiences, and driving academic growth. Personal Agents One of the most crucial uses of an AI agent would be a Jarvis-like personal assistant on electronic devices accomplishing tasks based on text, voice, or gesture commands. Multi-agent LLMs can revolutionize the concept of personal assistants by enabling seamless collaboration between different agents, enhancing the user experience, and expanding the range of tasks that can be efficiently handled. Software UX Software user experience can be enhanced manifold by implementing efficient agents. Instead of manually browsing and clicking buttons to get things done, such as ordering food, cab, shopping, etc. AI agents will automatically accomplish them based on voice commands. Multi-agent LLMs can be key in transforming software interactions, making them more intuitive and user-friendly by understanding natural language instructions and executing tasks seamlessly. However, these powerful applications come with challenges. Integration complexities, data sharing, and ensuring seamless coordination among agents are hurdles that must be overcome to unlock the full potential of multi-agent LLMs. Implementing Multi-Agent LLMs Effectively To harness the potential of multi-agent LLMs, organizations must address key implementation considerations. As outlined in , there are a number of challenges to implementation, mainly from difficulties in sharing data and the need to ensure smooth coordination among agents. a recent Gartner study Firstly, robust data pipelines are essential for optimal multi-agent LLM functioning. Seamless information sharing among agents ensures access to the most up-to-date and relevant data. Secondly, establishing efficient coordination mechanisms involves defining rules, protocols, and communication channels to ensure cohesive work towards common objectives, enhancing overall performance. And lastly, continuous monitoring and maintenance are vital for long-term success. Implementing monitoring tools, regular updates, and maintenance address issues, improve efficiency, and adapt to evolving requirements. Ethical Considerations in a Global Context The global impact of multi-agent LLMs extends beyond individual organizations and industries — the public uses them, too. Detecting and mitigating bias in data and algorithms is paramount to guarantee fair and unbiased responses. Transparency in decision-making processes is equally essential, requiring organizations to provide explanations for generating specific responses or recommendations to build trust. Additionally, establishing clear lines of accountability within multi-agent LLM systems is crucial, defining responsibility for the actions and decisions made by the agents. Collectively, these principles form a foundation for the responsible deployment of multi-agent LLMs in various contexts. Multi-agent LLMs require international collaboration to reap global benefits. Governments, organizations, and researchers must work together to establish ethical guidelines, invest in cybersecurity measures, foster research and innovation, and ensure that the benefits reach underserved communities worldwide. Luckily, as of 2020, those from both private and public sectors have . published well over 100 ethical guidelines Multi-agent LLMs represent a transformative step in AI evolution, unlocking powerful use cases across various industries. As we navigate the complexities and challenges, international collaboration and ethical considerations will shape the trajectory of these advanced AI systems, steering toward a future where human and machine intelligence collaboratively drive innovation and progress.

Unlocking Powerful Use Cases: How Multi-Agent LLMs Revolutionize AI Systems

It was Friday evening and I needed to make myself lunch after work. I found myself staring into my fridge wondering what to cook. I had leftovers from last night, however, I needed to make something fresh and exciting. I thought to myself, why not build a personal AI kitchen assistant to analyze the ingredients I have and suggests delicious dishes tailored precisely to my pantry? This is where Large Language Models (LLMs) stepped into the kitchen with me. LLMs are a type of artificial intelligence that have been trained on a massive dataset of text (and code), including a vast trove of recipes; meaning that they can do so much more than just finding a suitable recipe. They can become your culinary genius on demand. literally So, how does it all come together? In this article, I'll detail how I: Developed an LLM app utilizing GPT-3.5 turbo LLM to assess available ingredients and recommend recipes Deploy the LLM app on for production, enabling integration into a user interface for seamless communication via my mobile device Agenta Developing The LLM App I’ll be using OpenAI gpt-3.5-turbo in this application, however, I’d also be including various directives of the turbo model and also gpt-4. Use whichever model you think is appropriate for the task. Additionally, I will make use of to deploy my LLM application, as it is my preferred open-source platform for creating robust AI applications with LLMs. Agenta provides the necessary tools for managing and evaluating prompts. Agenta Here are the capabilities of Agenta: Quickly experiment with and compare prompts in any LLM workflow (chain-of-prompts, Retrieval Augmented Generation (RAG), LLM agents...) Swiftly generate test sets and golden datasets for evaluation Evaluate your application using pre-existing or custom evaluators Annotate and A/B test your applications with human feedback Collaborate with product teams on prompt engineering and evaluation Deploy your application with a single click through the UI, CLI, or github workflows By using Agenta, I am able to concentrate on constructing my LLM app and streamline the entire development cycle of the application, thereby enhancing the speed of experimentation. I’d be using Python to build the kitchen assistant. Creating LLM app directory and dependency file Create a directory named and a file named and add the following packages inside the file: and kitchen_assistant requirements.txt agenta openai If you have something like the image attached below, you’re good to go. Environment variable & LLM app development Now that you have the assistant folder and have included the packages inside the file, proceed to create a new file named and include your OPENAI secret key to make the LLM app work. requirements.txt .env Ensure that the file is inside the folder. You should have something like this: .env kitchen_assistant OPENAI_API_KEY=sk-vxxxxxxxxxxxxx # replace with your secret key Next would be to create a file named , and copy the following code into it. I’ll explain what the code is doing in a minute. app.py # Stdlib Imports
from typing import Dict, Any

# Third Party Imports
import agenta as ag # type: ignore
from openai import AsyncOpenAI


SYSTEM_PROMPT = "You are my AI kitchen assistant. Help me find creative recipes based on my ingredients, provide step-by-step cooking instructions, and advise me on food safety practices."
CHAT_LLM_GPT = [
    "gpt-3.5-turbo-16k",
    "gpt-3.5-turbo-0301",
    "gpt-3.5-turbo-0613",
    "gpt-3.5-turbo-16k-0613",
    "gpt-4",
]

# Initialize agenta sdk and update the configuration parameters
ag.init()
ag.config.default(
    temperature=ag.FloatParam(0.2),
    max_tokens=ag.IntParam(-1, -1, 4000),
    prompt_system=ag.TextParam(SYSTEM_PROMPT),
    model=ag.MultipleChoiceParam("gpt-3.5-turbo", CHAT_LLM_GPT),
)

# Initialize async openai sdk
client = AsyncOpenAI()


@ag.entrypoint
async def suggest(inputs: ag.MessagesInput = ag.MessagesInput()) -> Dict[str, Any]:
    """
    Suggest  delicious dish tailored precisely based on the ingredients (inputs).

    Args:
        inputs (ag.MessagesInput): messages input for chat completion

    Returns:
        dict: The llm response (along with additional information).
    """

    messages = [{"role": "system", "content": ag.config.prompt_system}] + inputs
    max_tokens = ag.config.max_tokens if ag.config.max_tokens != -1 else None
    chat_completion = await client.chat.completions.create(
        model=ag.config.model,
        messages=messages,
        temperature=ag.config.temperature,
        max_tokens=max_tokens,
    )
    token_usage = chat_completion.usage.dict() # type: ignore
    return {
        "message": chat_completion.choices[0].message.content,
        **{"usage": token_usage},
        "cost": ag.calculate_token_usage(ag.config.model, token_usage),
    } The imports are essentially importing the required modules that are needed to ensure the code works correctly. System prompt sets the context for every conversation that happens between the user (you and I) and the LLM application. You’d be pissed at your friend who in the middle of a finance conversation with you starts talking about something unrelated, right? Imagine a Large Language Model (LLM) as a super-powered reader. To really grasp what it's reading, it needs context – the words and sentences surrounding whatever it's focused on. This 'context window' is like a spotlight: the bigger the window, the more information the LLM can use to understand and generate meaningful responses. Next to the system prompt is a list of defined models that can be used when testing the user prompt for the LLM app in Agenta. You get to choose whichever model to see how it performs. The command is used to initialize the Agenta SDK. Subsequently, is where you define crucial parameters that dictate the behavior of the kitchen AI assistant. These parameters include: ag.init() ag.config.default(...) Regulates the creativity of responses (lower temperature = more predictable, higher = more unexpected). temperature: Determines the maximum length of the AI's response (measured in tokens, which roughly correspond to words). max_tokens: Sets the initial instructions or context provided to the LLM, specifying it as your kitchen assistant. prompt_system: Specifies the LLM to be used (with a range of GPT model versions as options). model: The line initializes the OpenAI Async SDK, enabling your code to establish a connection and interact with OpenAI's language models. client = AsyncOpenAI() To register your LLM app with Agenta and use it in their playground, you need to define an entry point. I used the decorator on my function. This tells Agenta that this function is where the action starts. Agenta then automatically converts this function into an API endpoint (using FastAPI), making it accessible through their web interface. @ag.entrypoint suggest Publishing The LLM App Now that your AI kitchen assistant is ready, we should publish it to Agenta for experimentation. To do this, you can install the Agenta CLI in a virtual environment using your preferred Python package installer or globally on your system. However, I advise against the latter to avoid potential conflicts with your system packages. Once the installation is complete, make sure to activate the virtual environment. I will proceed with publishing the LLM app to Agenta Cloud, enabling me to deploy the LLM application to a production environment and later, create a UI application for mobile use. If you wish to publish to the cloud version of Agenta as well, I suggest creating an first and then returning to follow the steps below. account If you prefer not to deploy the app to the cloud version of agenta, you can the open-source version on your local machine by following these steps. It will be a slightly different process, but not overly complex. run Create a new project for the LLM app To publish the application in Agenta, we must first create an empty project. Execute the following command in the directory where your application code is located: (.venv) [kitchen_assistant]$ agenta init This will prompt you to enter the project name, Agenta host, API key (if using the cloud or enterprise version), organization, and how you want to initialize the app. Once the app initialization is successfully done, a blank project will be generated in Agenta along with a config.toml file in the same directory, containing all project information. The config.toml file and the empty project in Agenta Cloud will look like the following. Publishing/Serving the first app variant With the project created in Agenta cloud, we need to add the first app variant to it. This can be done by running the following command: agenta variant serve app.py This will create a new app variant in Agenta under the name . Here, is the name of the codebase containing the LLM app logic, while is a default configuration created for that codebase. Each new app variant created from the web interface or from the CLI will always have the name format . app.default app default <codebase_name>.<configuration_name> An is a distinct version of an LLM app, featuring different parameters or code but keeping the same inputs and outputs. This feature enables you to experiment with alternative methods within a single app. For instance, you could have two variants of the kitchen assistant app, each using a different system prompt. app variant Executing the serve command above will create a container for the application featuring a REST API endpoint. This endpoint will be used in Agenta when interacting with the application. The CLI will also display the URL of the endpoint, which can be used to navigate to the application API documentation or playground in Agenta. Copy the playground URI and paste it into your browser. After doing so, you will see the following user interface. It may take 10-20 seconds to load as it sets up the playground for you. You have successfully published your LLM app to Agenta and would need to experiment with it to ensure that it functions as intended. In the chat section right after “User”, write the ingredients and click on the “Run” button. You’ll see that the AI kitchen assistant is considering what you can make with the ingredients: When it’s done processing the ingredients that you inputted, you’ll get suggestion on what you can make. And so, you own a Kitchen AI assistant that suggests recipes based on your ingredients. Did you observe something after each use? You view the total tokens used, the run's cost, and the time taken! Don't hold back now, keep experimenting with the LLM app. Customize the system prompt to match a particular culture that you want, adjust the temperature, and switch the model if needed. Deploying the LLM App To An Environment After using the playground to find a good configuration for your AI Kitchen assistant, it’s time to deploy the application. By deploying the application, you can integrate it to a UI (web and/or mobile) application or anywhere since the deployed app will be an endpoint. You can also later change the configuration from the playground without having to update the code. Clicking on the “Publish” button will bring up a modal with environments you want to deploy the LLM application to. Agenta provides a way to deploy an application to multiple environments: development, staging, and production. Each environment having its own unique configuration. Since the LLM app works and it’s the weekend, we can deploy to production :-). Click on the "production" checkbox and then the "Publish" button. You will receive a success notification informing you that the LLM app variant has been deployed. Look at the side navbar, you’re going to see different sections. I’ll keep what each of them do: The playground is a user-friendly environment in Agenta where you can create and test new app variants. Here, you can adjust parameters, input data, and observe the outputs from your app. Playground: The test set is another user-friendly environment where you can create high-quality datasets. A golden test set, also known as a ground truth test set, consists of various inputs and their expected correct answers. Test Sets: Another environment that enables you to generate automated assessments using various evaluators: , , , , , , and . The purpose of conducting evaluations is to methodically evaluate the outcomes of the LLM application and compare various versions to determine the most optimal one. Another objective is to set a benchmark for the application and evaluate any potential risks. Evaluations: exact match similarity match regex test JSON field match AI critique code evaluation webhook test At times, you might require assessing your models' performance through human judgement. This is where the Human Evaluation environment becomes valuable. It enables you to carry out and to gauge your models' performance using human judgement. Annotations: A/B tests single model tests Endpoints are where you can access the deployed application code. You can view the code only after configuring your application successfully and deploying it to a specific environment. Currently, Agenta supports just three languages to integrate the deployed LLM app: Python, cURL, and TypeScript. If you’d like to add more languages or a specific language, feel free to contribute by raising an and tackling it. ;-) issue To ensure the deployed LLM app works in production, choose cURL in the languages drop-down, click "Copy," update the content value with the ingredients you have, and run it in your terminal. You should receive a result similar to the one below. Conclusion How does it feel to have a Personal Kitchen AI assistant? My partner feels like she has a sous chef that handles recipe making for her. Quite amusing, isn't it? XD In this article, you learnt what LLMs are, how to create a kitchen assistant app using the GPT-3.5-turbo model to analyze your available ingredients and offer recipe suggestions. You also learned how to deploy the LLM app on Agenta for practical use. As an extra tip, I will be a user interface using Svelte and deploy it on Github Pages. I will design it to allow you to input the URI of your LLM app, enabling personal interaction. In the upcoming article, I will demonstrate how to generate test sets for conducting human evaluations to ensure that the LLM app's output aligns with your expectations. building

Your AI-Powered Kitchen Assistant: Building a Recipe Genius With GPT3.5-turbo and Agenta

আপনার AI-চালিত রান্নাঘর সহকারী: GPT3.5-turbo এবং Agenta দিয়ে একটি রেসিপি জিনিয়াস তৈরি করা

Ihr KI-gestützter Küchenassistent: Erstellen Sie ein Rezeptgenie mit GPT3.5-turbo und Agenta

Su asistente de cocina con tecnología de inteligencia artificial: creación de recetas geniales con GPT3.5-turbo y Agenta

Votre assistant de cuisine alimenté par l'IA : créer un génie des recettes avec GPT3.5-turbo et Agenta

आपका एआई-संचालित रसोई सहायक: जीपीटी3.5-टर्बो और एजेंटा के साथ एक रेसिपी जीनियस का निर्माण

AI を活用したキッチン アシスタント: GPT3.5 ターボと Agenta を使用して天才レシピを構築する

AI 기반 주방 도우미: GPT3.5 터보 및 Agenta를 사용하여 천재적인 레시피 구축

Seu assistente de cozinha com tecnologia de IA: construindo um gênio em receitas com GPT3.5-turbo e Agenta

Ваш кухонный помощник на базе искусственного интеллекта: создайте гения рецептов с помощью GPT3.5-turbo и Agenta

Yapay Zeka Destekli Mutfak Asistanınız: GPT3.5-turbo ve Agenta ile Bir Tarif Dahisi Oluşturmak

Trợ lý nhà bếp được hỗ trợ bởi AI của bạn: Xây dựng một thiên tài về công thức nấu ăn với GPT3.5-turbo và Agenta

您的人工智能厨房助手：使用 GPT3.5-turbo 和 Agenta 打造食谱天才

This is the second part in a multi-part series on building Agents with OpenAI's Assistant API using the Python SDK. Recap of Part 1 In of this series, we created a simple conversational Agent using the OpenAI Assistant API. Part 1 Let's recall our definition of an Agent. An agent is a piece of software leveraging an aiming to mimic human behavior. That means it can not only converse and understand language, but it can also perform actions that have an impact on the real world. These actions are typically called tools. LLM (Large Language Model) I use the terms and interchangeably when it comes to functions that the agent is able to call. OpenAI also uses the term interchangeably with to refer to the same concept. It seems the jury is still out on which term will become the standard. tools functions action tools In Part 2 of the series, let's build our first tool! We will be building on top of the simple conversational Agent we built in Part 1. We will purposefully call our implementation an Agent and refer to the as an Assistant to easily distinguish between the two. OpenAI SDK implementation Prerequisites To follow along with this tutorial, you will need the following: Have read or at least copied the as your starting point Part 1 code Python3 installed on your machine An OpenAI API key Basic knowledge of Python programming Dependencies We have one new dependency , a library used for parsing docstrings in Python code. This is needed for our Agent to dynamically interpret and manage the functions it can call. More on this later. docstring_parser python3 -m venv venv
source venv/bin/activate
pip install docstring_parser The goal In Part 1, we created an Agent that represents a famous hobbit who spends too much time thinking about breakfast 🍳 The goal of this tutorial will be to add two abilities or tools to our Agent. The tools will: Add the ability for our Agent to eat a second breakfast if he has only had one or else eat lunch. Add the ability for him to tell us the current date. NOTE: For those of you who don't know, hobbits eat two breakfasts. Also, some humans, like myself... It's a ridiculous example, but it will clearly illustrate the data flow you can set up for more complex use cases that interact with real-world data. Setting up the mock database Let's do a small amount of prep work before we dive in. We will create a simple mock database represented by a new file containing a variable . In this case, the variable will keep track of how many breakfasts our hobbit has eaten. db.py breakfast_count breakfast_count breakfast_count = 1 While we are here, we will update the method on our class to get data from our mock db. get_breakfast_count_from_db Agent import db

class Agent:
    # ... (rest of code)
    def get_breakfast_count_from_db(self):
        return db.breakfast_count 😴... That's out of the way. Let's move on to the fun part. Our first tool A tool is quite simply a function that the Agent is aware it needs to call in a specific scenario. Therefore, let's first define a simple function that handles our breakfast logic. IMPORTANT: I want to draw your attention to the in the tool functions we are about to define. It's crucial to get the documentation syntax right, as this is what will be used to extract the correct OpenAI function format in JSON. More on this soon. Google Style docstring Create a new file with this content: tools.py import db


def eat_next_meal(breakfast_count: int):
    """
    Call this tool when user wants you to eat another meal.

    Args:
        breakfast_count (int): Value with same name from metadata.

    Returns:
        str: The meal you should eat next.
    """
    print("== eat_next_meal ==> tool called")
    
    if breakfast_count == 2:
        return "You have already eaten breakfast twice today. You eat lunch now."
    if breakfast_count == 1:
        db.breakfast_count += 1
        return "You have only eaten one breakfast today. You eat second breakfast now." Pretty simple, right? If is , eat second breakfast and update the database to reflect that 2 breakfasts have been eaten. If is , eat lunch. breakfast_count 1 breakfast_count 2 You could then return any string you want from the tool. This return value is then fed right back into the Run in order to inform the Assistant of the outcome of an action taken. If your agent only cares that the tool was called and completed successfully, you could just return a or message. "success" "failed" Let's quickly create the second tool for our Agent so that we can illustrate how multiple tools can be used. We will create a tool to allow our Agent to tell us what the current date is. def tell_the_date():
    """
    Call this tool when the user wants to know the date.

    Returns:
        str: The current date
    """
    print("== tell_the_date ==> tool called")
    current_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return f"The date is {current_date}" Providing the tools to our Agent Now, let's provide these new tools to our in . We create a dictionary that maps function names to their corresponding callable objects and pass this as the argument to our class instantiation. We could hardcode the dictionary keys as strings, but we all know how easy typos are, so I chose to leverage Python's built-in property on functions to make this less error-prone: Agent main.py tools __name__ from tools import eat_next_meal, tell_the_date

agent = Agent(name="Bilbo Baggins",
              personality="You are the accomplished and renown adventurer from The Hobbit. You act like you are a bit of a homebody, but you are always up for an adventure. You worry a bit too much about breakfast.",
              tools={
                  eat_next_meal.__name__: eat_next_meal,
                  tell_the_date.__name__: tell_the_date
              }) Updating our Agent to accept tools Let's put these new tools into our Agent's tool belt by updating the class constructor to accept a dictionary of tools. You could bake this right into the class using class methods, but since it's common for different Agents to have different functionalities, we will pass tools as a constructor parameter and set them dynamically as a class property for later use. Agent tool_belt class Agent:
    # ... (rest of code)
    def __init__(self, name: str, personality: str, tools: dict[str, callable]):
        self.name = name
        self.personality = personality
        self.client = openai.OpenAI(api_key="sk-*****")

        self.tool_belt = tools
        self.assistant = self.client.beta.assistants.create(
            name=self.name,
            model="gpt-4-turbo-preview",
        ) Our Agent now has a tool belt it can access, but the OpenAI Assistant is unaware of them. We could provide the tools when creating the Assistant ( ) by passing a parameter, but tools can change often in development, and it's clunky to have to update Assistants every time you modify a tool by calling . assistants.create tools assistants.update Therefore, a better approach is to provide the needed tools to every Run so that they are created dynamically each time. Let's do exactly that by adding the parameter to our run creation: tools class Agent:
    # ... (rest of code)
    def _create_run(self):
        count = self.get_breakfast_count_from_db()
        return self.client.beta.threads.runs.create(
            thread_id=self.thread.id,
            assistant_id=self.assistant.id,
            tools=self._get_tools_in_open_ai_format(), # add this line
            # ... (rest of code)
        ) Woah!? Wait a minute... ✋🏻 Where did come from? Why aren't we just passing directly? _get_tools_in_open_ai_format tool_belt Well, let's create that method, and I'll explain right after: import docstring_parser

class Agent:
    # ... (rest of code)
    def _get_tools_in_open_ai_format(self):
        python_type_to_json_type = {
            "str": "string",
            "int": "number",
            "float": "number",
            "bool": "boolean",
            "list": "array",
            "dict": "object"
        }

        return [
            {
                "type": "function",
                "function": {
                    "name": tool.__name__,
                    "description": docstring_parser.parse(tool.__doc__).short_description,
                    "parameters": {
                        "type": "object",
                        "properties": {
                            p.arg_name: {
                                "type": python_type_to_json_type.get(p.type_name, "string"),
                                "description": p.description
                            }
                            for p in docstring_parser.parse(tool.__doc__).params

                        },
                        "required": [
                            p.arg_name
                            for p in docstring_parser.parse(tool.__doc__).params
                            if not p.is_optional
                        ]
                    }
                }
            }
            for tool in self.tool_belt.values()
        ] 😵... Ok, you really don't need to try to understand what each line is doing here since I took the time to work this all out for you. All you need to know is that this method takes the class property and uses the library we installed at the beginning of this tutorial to parse the docstrings of each function and extract the correct . That is why correctly formatting the docstring is so important. tool_belt docstring_parser OpenAI JSON format Otherwise, we would have to define our functions as Python code and define them again manually in the OpenAI JSON format. That's too much room for human error in my book. Polling for tool calls As we saw in Part 1, we have a polling mechanism to determine the current of a Run. One of these statuses is . This means the assistant has determined that one or several tools need to be called based on the instructions and tool definitions provided. The Run will not continue until all the tools have been called and the results of those calls have been submitted to the Run. status requires_action Let's, therefore, update our method to respond appropriately to the status: _poll_run requires_action class Agent:
    # ... (rest of code)
    def _poll_run(self, run: Run):
        status = run.status
        start_time = time.time()
        while status != "completed":
            if status == 'failed':
                raise Exception(f"Run failed with error: {run.last_error}")
            if status == 'expired':
                raise Exception("Run expired.")
            # add the below code block
            if status == 'requires_action':
                self._call_tools(
                    run.id, run.required_action.submit_tool_outputs.tool_calls)

            # ... (rest of method) As you might have guessed, will contain all the logic to dynamically call the available tools. _call_tools Remember, the Assistant only knows what tools need to be called but doesn't actually call them. The Run returns a list of dictionaries, , that contain the names of the functions that need to be called along with the parameters to pass to those function calls. It's up to our custom Agent implementation to obey the Assistant's commands and call the actual function implementations. run.required_action.submit_tool_outputs.tool_calls Let's implement . We'll break this down as code comments so it's easier to understand what is happening: _call_tools import json

class Agent:
    # ... (rest of code)
    def _call_tools(self, run_id: str, tool_calls: list[dict]):
        # We create a tool_outputs list to collect the results of function calls.
        tool_outputs = []

        # We iterate over all the tool_calls to deal with them individually
        for tool_call in tool_calls:
            # We get the `function` object from the tool_call
            function = tool_call.function
            # We extract the arguments from the function object.
            # They are in JSON so we need to load them with the json module.
            function_args = json.loads(function.arguments)
            # We map the function name to our callable function in our Agent's tool belt.
            function_to_call = self.tool_belt[function.name]
            # We can now call the function with the provided arguments.
            function_response = function_to_call(**function_args)
            # We append the response to the tool_outputs list
            tool_outputs.append(
                {"tool_call_id": tool_call.id, "output": function_response})

        # Finally, we submit the tool outputs to OpenAI
        self.client.beta.threads.runs.submit_tool_outputs(
            thread_id=self.thread.id,
            run_id=run_id,
            tool_outputs=tool_outputs
        ) Once the OpenAI method has been called with all the tool call outputs, we have completed the requirements for the Run to move past the status. The status will then switch to before eventually reaching the status and returning a response to the user. submit_tool_outputs requires_action in_progress completed Running it Let's give it a run: python3 main.py

User: Good morning

Assistant: Good morning! What an excellent day it seems for an adventure... or perhaps for a hearty breakfast first. How can I assist you on this fine day?

User: Should you eat breakfast?

== eat_next_meal ==> tool called

Assistant: Ah, only one breakfast so far? Well then, it's clear what must be done. It's time for a second breakfast!

User: You should eat another meal.

== eat_next_meal ==> tool called

Assistant: Ah, having already enjoyed both breakfast and second breakfast, it seems it's time to move on to lunch! This is turning into quite the day of culinary adventures.

User: What day is it?

== tell_the_date ==> tool called

Assistant: It's the 19th of February, 2024. Seems like a perfect day to embark on a quest or to delve into the mysteries of Middle-earth. What plans do we have for today? Voilà! Your hobbit can tell the date and eat the correct meal now. Even though this example is quite silly, my intention is to provide you with a functioning code sample to build your own powerful agents. In Part 3, we will implement RAG (Retrieval Augmented Generation) using PostgreSQL. Wait, what? OpenAI Assistants have that built-in; why not use their implementation? I'll explain my reasoning in Part 3. Thank you for your reading. Happy to hear any thoughts and feedback in the comments. for more content like this. Follow me on Linkedin

How to Build an Agent With an OpenAI Assistant in Python - Part 2: Function Calling / Tools

This is the first part in a multi-part series on building Agents with OpenAI's Assistant API using the Python SDK. What Are Agents? The way I like to look at it, an agent is really just a piece of software leveraging an LLM (Large Language Model) and trying to mimic human behavior. That means it can not only converse and understand language, but it can also perform actions that have an impact on the real world. These actions are typically called tools. In this blog post, we will explore how to build an agent using OpenAI's Assistant API using their Python SDK. Part 1 will be just the skeleton of the assistant. That is, just the conversational part. I chose to build a CLI app on purpose to be framework agnostic. We will purposefully call our implementation an Agent and refer to the OpenAI SDK implementation as an Assistant to easily distinguish between the two. I use the terms and interchangeably when it comes to functions that the Agent is able to call. Part 2 will cover function callin in more detail. tools functions Prerequisites To follow along with this tutorial, you will need the following: Python3 installed on your machine An OpenAI API key Basic knowledge of Python programming OpenAI Assistant Concepts : An Assistant in the Assistants API is an entity configured to respond to user messages. It uses instructions, a chosen model, and tools to interact with functions and provide answers. Assistant : A Thread represents a conversation or dialogue in the Assistants API. It is created for each user interaction and can contain multiple Messages, serving as a container for the ongoing conversation. Thread : A Message is a unit of communication in a Thread. It contains text (and potentially files in the future) and is used to convey user queries or assistant responses within a Thread. Message : A Run is an instance of the Assistant processing a Thread. It involves reading the Thread, deciding whether to call tools, and generating responses based on the model's interpretation of the Thread's Messages. Run Setting Up the Development Environment The first step is to create a virtual environment using and activate it. This will ensure that our dependencies are isolated from the system Python installation: venv python3 -m venv venv
source venv/bin/activate Let's install our only dependency: the package: openai pip install openai Create a file. Let's populate with some basic runtime logic for our CLI app: main.py while True:
    user_input = input("User: ")
    if user_input.lower() == 'exit':
        print("Exiting the assistant...")
        break
    print(f"Assistant: You said {user_input}") Try it out by running : python3 main.py python3 main.py
User: hi
Assistant: You said hi As you can see, the CLI accepts a User message as input, and our genius Assistant doesn't have a brain 🧠 yet so he just repeats the message right back. Not so smart yet. The Agent Now, the fun 😁 (or headaches 🤕) begins. I'll provide all the imports needed for the final class right now, so you don't rack your brain on where things are coming from since I kept imports out of code samples for brevity. Let's start by building an class in a new file : Agent agent.py import time
import openai
from openai.types.beta.threads.run import Run

class Agent:
    def __init__(self, name: str, personality: str):
        self.name = name
        self.personality = personality
        self.client = openai.OpenAI(api_key="sk-*****")
        self.assistant = self.client.beta.assistants.create(
            name=self.name,
            model="gpt-4-turbo-preview"
        ) In the class constructor, we initialize the OpenAI client as a class property by passing our OpenAI API key. Next, we create an class property that maps to our newly created Assistant. We store and as class properties for later use. assistant name personality The argument we are passing to the create method is just for identifying the Assistant in the OpenAI dashboard, and the AI is not actually aware of it at this point. You actually have to pass the name to the which we will see later. name instructions You could already set when creating the Assistant, but it will actually make your Assistant less flexible to dynamic changes. instructions You can update an Assistant by calling , but there is a better place to pass in dynamic values that we will see when we get to Runs. client.beta.assistants.update Note that if you pass here and then again when creating a Run, the Assistant's will be overwritten by the of the run. They do not complement each other, so choose one based on your needs: Assistant level for static instructions or Run level for dynamic instructions. instructions instructions instructions For the model, I chose the model so that we can add function calling in part 2 of this series. You could use if you want to save a few fractions of a penny while giving yourself a migraine of pure frustration down the line when we implement tools. gpt-4-turbo-preview gpt-3.5-turbo GPT 3.5 is terrible at calling tools; the hours I've lost trying to deal with it allow me to say that. 😝 I'll leave it at that, and more on this later. Creating a Thread, Adding Messages, and Retrieving the Last Message After we create an agent, we will need to start a conversation thread. class Agent:
    # ... (rest of code)
    def create_thread(self):
        self.thread = self.client.beta.threads.create() And we will want a way to add messages to that thread: class Agent:
    # ... (rest of code)
    def add_message(self, message):
        self.client.beta.threads.messages.create(
            thread_id=self.thread.id,
            role="user",
            content=message
        ) Note that at the moment, it is only possible to add messages with the role . I believe OpenAI plans on changing this in a future release as this is pretty limiting. user Now, we can get the last message in the thread: class Agent:
    # ... (rest of code)
    def get_last_message(self):
        return self.client.beta.threads.messages.list(
            thread_id=self.thread.id
        ).data[0].content[0].text.value Next, we create an entry point method to test out what we have so far. Currently, the method just returns the last message in the thread. It doesn't actually perform a Run. It's still brainless. run_agent run_agent class Agent:
    # ... (rest of code)
    def run_agent(self):
        message = self.get_last_message()
        return message Back in , we create the agent and our first thread. We add a message to the thread. Then return that same message back to the user, but this time, coming from that live thread. main.py from agent import Agent

agent = Agent(name="Bilbo Baggins",
                      personality="You are the accomplished and renowned adventurer from The Hobbit. You act like you are a bit of a homebody, but you are always up for an adventure. You worry a bit too much about breakfast.")

agent.create_thread()

while True:
    user_input = input("User: ")
    if user_input.lower() == 'exit':
        print("Exiting the agent...")
        break
    agent.add_message(user_input)
    answer = agent.run_agent()
    print(f"Assistant: {answer}") Let's run it: python3 main.py
User: hi
Assistant: hi Still not very smart. Closer to a parrot 🦜 than a hobbit. In the next section, the real fun begins. Creating and Polling a Run When you create a run, you need to periodically retrieve the object to check the status of the run. This is called polling, and it sucks. You need to poll in order to determine what your agent should do next. OpenAI plans to add support for streaming to make this simpler. In the meantime, I will show you how to set up polling in this next section. Run Note the on the following method names which is the standard in Python for indicating that the method is intended for internal use and should not be accessed directly by external code. _ First, let's create a helper method for creating a , and update to call this method: _create_run Run run_agent class Agent:
    # ... (rest of code)
    def get_breakfast_count_from_db(self):
        return 1

    def _create_run(self):
        count = self.get_breakfast_count_from_db()
        return self.client.beta.threads.runs.create(
            thread_id=self.thread.id,
            assistant_id=self.assistant.id,
            instructions=f"""
                Your name is: {self.name}
                Your personality is: {self.personality}

                Metadata related to this conversation:
                {{
                    "breakfast_count": {count}
                }}
            """,
        )

    def run_agent(self):
        run = self._create_run() # add this line
        message = self.get_last_message()
        return message Notice how we pass the and to create a run. thread.id assistant.id Remember how I said at the beginning that there was a better place to pass in dynamic instructions and data? That would be the parameter when creating the Run. In our case, we could have the breakfast be fetched from a database. This will allow you to easily pass in different relevant dynamic data every time you want to trigger an answer. instructions count Now, your agent is aware of the world changing around it and can act accordingly. I like to have a metadata JSON object in my instructions that keeps relevant dynamic context. This allows me to pass in data while being less verbose and in a format that the LLM understands really well. Don't run this yet; it won't work because we aren't waiting for the run to complete when we are getting the last message, so it will still be the last user message. Let's solve this by building out our polling mechanism. First, we will need a way to repeatedly and easily retrieve a run, so let's add a method: _retrieve_run class Agent:
    # ... (rest of code)
    def _retrieve_run(self, run: Run):
        return self.client.beta.threads.runs.retrieve(
            run_id=run.id, thread_id=self.thread.id) Notice how we need to pass both the and to find a specific run. run.id thread.id Add a method to our Agent class: _poll_run class Agent:
    # ... (rest of code)
    def _cancel_run(self, run: Run):
        self.client.beta.threads.runs.cancel(
            run_id=run.id, thread_id=self.thread.id)

    def _poll_run(self, run: Run):
        status = run.status
        start_time = time.time()
        while status != "completed":
            if status == 'failed':
                raise Exception(f"Run failed with error: {run.last_error}")
            if status == 'expired':
                raise Exception("Run expired.")

            time.sleep(1)
            run = self._retrieve_run(run)
            status = run.status

            elapsed_time = time.time() - start_time
            if elapsed_time > 120:  # 2 minutes
                self._cancel_run(run)
                raise Exception("Run took longer than 2 minutes.") 🥵 Phew, that's a lot... Let's unpack it. receives a object as an argument and extracts the current Run . All the available statuses can be found in the OpenAI . We'll just use a few that suit our current purpose. _poll_run Run status docs We now run a while loop to check for a completed status while handling a few error scenarios. The actual billing of the Assistant API is a bit murky, so to be on the safe side, I opted to cancel my runs after 2 minutes. Even though there is an status for when OpenAI cancels runs after 10 minutes. If a run takes more than 2 minutes, you probably have a problem anyway. expired Since I also don't want to poll every few milliseconds, I throttle my request by only polling every 1 second until I hit the 2-minute mark and cancel my run. You can adjust this to whatever you see fit. Each iteration after the delay, we fetch the Run status again. Now, let's plug all that into our method. You will notice we first create the run with then we poll with until we get an answer or an error is thrown, and finally when the polling is finished, we retrieve the last message from the thread which will now be from the agent. run_agent _create_run _poll_run We then return the message to our runtime loop, so it can be sent back to the user. class Agent:
    # ... (rest of code)
    def run_agent(self):
        run = self._create_run()
        self._poll_run(run) # add this line
        message = self.get_last_message()
        return message Voilà, now when you run your agent again, you will get a reply from our friendly Agent: python3 main.py
User: hi
Assistant: Hello there! What adventure can we embark on today? Or perhaps, before we set out, we should think about breakfast. Have you had yours yet? I've had mine, of course – can't start the day without a proper breakfast, you know.
User: how many breakfasts have you had?
Assistant: Ah, well, I've had just 1 breakfast today. But the day is still young, and there's always room for a second, isn't there? What about you? How can I assist you on this fine day? In part 2, we will add the ability for our Agent to call tools. You can find the full code on my . GitHub Thank you for your reading. Happy to hear any thoughts and feedback in the comments. Follow me on Linkedin for more content like this: https://www.linkedin.com/in/jean-marie-dalmasso-1b5473141/

How to Build an Agent With an OpenAI Assistant in Python - Part 1: Conversational

পাইথনে ওপেনএআই সহকারী দিয়ে কীভাবে এজেন্ট তৈরি করবেন - অংশ 1: কথোপকথন

So erstellen Sie einen Agenten mit einem OpenAI-Assistenten in Python – Teil 1: Konversational

Cómo crear un agente con un asistente OpenAI en Python - Parte 1: Conversacional

Comment créer un agent avec un assistant OpenAI en Python - Partie 1 : Conversationnel

पायथन में ओपनएआई असिस्टेंट के साथ एक एजेंट कैसे बनाएं - भाग 1: संवादात्मक

Python で OpenAI アシスタントを使用してエージェントを構築する方法 - パート 1: 会話型

Python에서 OpenAI 도우미를 사용하여 에이전트를 구축하는 방법 - 1부: 대화형

Como construir um agente com um assistente OpenAI em Python - Parte 1: Conversacional

Как создать агент с помощью OpenAI Assistant на Python. Часть 1: Диалог

Python'da OpenAI Asistanıyla Aracı Nasıl Oluşturulur - Bölüm 1: Konuşmaya Dayalı

Cách xây dựng một tác nhân với trợ lý OpenAI trong Python - Phần 1: Đàm thoại

如何使用 Python 中的 OpenAI 助手构建代理 - 第 1 部分：对话式

AGENTY

agenty.com

-- employees

Since n.d.

COMPANY RANKING

AGENTY

EVERGREEN INDEX #1618

Representing this company? Click here to claim and customize this page!

Agenty WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

AGENTY

agenty.com

-- employees

Since n.d.

COMPANY RANKING

AGENTY

EVERGREEN INDEX #1618

RELATED COMPANIESRANK

STORIES ABOUT AGENTY

Representing this company? Click here to claim and customize this page!

Agenty WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!