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

agenty

The Federal Investigation Agency will no longer be investigating or dealing with electronic crimes under its Cyber Crime Wing as the federal government has established another body afresh to do the...

Govt forms agency for cybercrime investigation anew | Pakistan | thenews.com.pk

NCCIA gets staff, inquiries, probes and liabilities of cybercrime wing.Staff of cybercrime wing will work till appointnent of NCCIA staff. New agency will directly register all cases related to cybercrime.

FIA's cybercrime wing stands defunct as govt constitutes new probe agency | Pakistan - Geo.tv

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

Creating a RAG Agent: Step-by-Step Guide

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Kiriaki Frangias;
(2) Andrew Lin;
(3) Ellen Vitercik;
(4) Manolis Zampetakis. Table of Links Abstract and Introduction Warm-up: Agents with known equal disutility Agents with unknown disutilites Experiments Conclusions and future directions, References A Summary of notation B Omitted proofs from Section 2 C Omitted proofs from Section 3 D Additional Information about Experiments 3 Agents with unknown disutilites We now significantly expand our model to study heterogeneous agents with differing, unknown disutilities. The full proofs of all results in this section are in Appendix C. 3.1 Model and notation Some agents might experience high disutility when exerting effort, so it may not be in the principal’s best interest to incentivize all agents to exert effort. Therefore, the principal must set the payment so that the number of agents incentivized is utility maximizing for the principal. For the rest of this section, we denote by g the number of agents that the principal aims to incentivize; in Theorem 3.6, we describe an efficient optimization problem that solves for the optimal value of g, denoted g∗. The principal controls the number of incentivized agents only through the payment function. Hence, the realized number of agents that exert effort, denoted ˆg, is a random variable with a distribution that depends on the payment. Under this model, the principal will: 1. Calculate g∗, the optimal number of agents to incentivize. 2. Announce the payment pg∗ ∈ R+ (based on g∗). 3. Verify a subset of comparisons assigned to the agents. 4. Assign each comparison to a total of r agents. 5. Pay pg∗ to all agents not identified as “bad.” 3.2 Payment function 3.3 Correctness of CrowdSort Next, we bound the redundancy required to ensure that CrowdSort returns the groundtruth ordering. Proof. We know from Lemma 3.4 that if then with high probability, the algorithm CrowdSort(T, s, v, r, δ) identifies all “bad” agents. Therefore, it suffices to assign each comparison to at least one “good” agent for the true value of the comparison to be returned. By Remark 3.3, we know that for any agent ai, So the probability that all r agents assigned to a single comparison are “bad” is at most: Taking the union bound over all comparisons, we have that the probability there exists a comparison such that all agents assigned to it are “bad” is at most Upper-bounding the above probability by δ/2, we get that: Finally, notice that the above inequality and Inequality (6) hold simultaneously with probability at least 1 − δ/2. 3.4 Principal’s incentive We combine the results presented above in the following theorem, in which we additionally prove that it is possible for the principal to efficiently compute the optimal number of agents to incentivize. Based on Lemma 3.5, we use the notation and This paper is available on Arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. Authors: (1) Kiriaki Frangias; (2) Andrew Lin; (3) Ellen Vitercik; (4) Manolis Zampetakis. This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Kiriaki Frangias; (2) Andrew Lin; (3) Ellen Vitercik; (4) Manolis Zampetakis. Table of Links Abstract and Introduction Abstract and Introduction Warm-up: Agents with known equal disutility Warm-up: Agents with known equal disutility Agents with unknown disutilites Agents with unknown disutilites Experiments Experiments Conclusions and future directions, References Conclusions and future directions, References A Summary of notation A Summary of notation B Omitted proofs from Section 2 B Omitted proofs from Section 2 C Omitted proofs from Section 3 C Omitted proofs from Section 3 D Additional Information about Experiments D Additional Information about Experiments 3 Agents with unknown disutilites We now significantly expand our model to study heterogeneous agents with differing, unknown disutilities. The full proofs of all results in this section are in Appendix C. 3.1 Model and notation Some agents might experience high disutility when exerting effort, so it may not be in the principal’s best interest to incentivize all agents to exert effort. Therefore, the principal must set the payment so that the number of agents incentivized is utility maximizing for the principal. For the rest of this section, we denote by g the number of agents that the principal aims to incentivize; in Theorem 3.6, we describe an efficient optimization problem that solves for the optimal value of g, denoted g∗. The principal controls the number of incentivized agents only through the payment function. Hence, the realized number of agents that exert effort, denoted ˆg, is a random variable with a distribution that depends on the payment. Under this model, the principal will: 1. Calculate g∗, the optimal number of agents to incentivize. 2. Announce the payment pg∗ ∈ R+ (based on g∗). 3. Verify a subset of comparisons assigned to the agents. 4. Assign each comparison to a total of r agents. 5. Pay pg∗ to all agents not identified as “bad.” 3.2 Payment function 3.3 Correctness of CrowdSort Next, we bound the redundancy required to ensure that CrowdSort returns the groundtruth ordering. Proof. We know from Lemma 3.4 that if then with high probability, the algorithm CrowdSort(T, s, v, r, δ) identifies all “bad” agents. Therefore, it suffices to assign each comparison to at least one “good” agent for the true value of the comparison to be returned. By Remark 3.3, we know that for any agent ai, So the probability that all r agents assigned to a single comparison are “bad” is at most: r Taking the union bound over all comparisons, we have that the probability there exists a comparison such that all agents assigned to it are “bad” is at most Upper-bounding the above probability by δ/2, we get that: Finally, notice that the above inequality and Inequality (6) hold simultaneously with probability at least 1 − δ/2. 3.4 Principal’s incentive We combine the results presented above in the following theorem, in which we additionally prove that it is possible for the principal to efficiently compute the optimal number of agents to incentivize. Based on Lemma 3.5, we use the notation and This paper is available on Arxiv under CC 4.0 license. This paper is available on Arxiv under CC 4.0 license. Arxiv Arxiv

Algorithmic Contract Design: What to Know About Agents With Unknown Disutilites 

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Kiriaki Frangias;
(2) Andrew Lin;
(3) Ellen Vitercik;
(4) Manolis Zampetakis. Table of Links Abstract and Introduction Warm-up: Agents with known equal disutility Agents with unknown disutilites Experiments Conclusions and future directions, References A Summary of notation B Omitted proofs from Section 2 C Omitted proofs from Section 3 D Additional Information about Experiments 2 Warm-up: Agents with known equal disutility As a warm up to our main result, in this section, we propose a contract assuming that (a) the principal knows the agents’ disutilites and (b) every agent experiences the same value of per-comparison disutility (assumptions we relax in Section 3). We begin with a formal model in Section 2.1 and define the optimal payment in Section 2.2. In Sections 2.3 and 2.4, we present our main algorithm CrowdSort for computing the correct sorting. Section 2.5 identifies conditions under which the principal gets higher utility when implementing our proposed contract than when performing all pairwise comparisons herself. The full proofs of all results in this section are in Appendix B. 2.1 Model and notation The interaction proceeds as follows: 1. The principal fixes a payment p∗ ∈ R+ that she will pay agents in order to incentivize them to exert effort. 2. The principal verifies a subset of the comparisons and announces the size of this set to the agents. 3. Agents choose whether to exert effort, which fixes their type upfront. 4. Agents are assigned verified and unverified comparisons. 2.2 Agents’ incentives 2.3 Peer grading algorithm 2.4 Allocation of items 2.4.1 Assigning verified comparisons. Lemma 2.3. If each item in V appears in exactly one pair, then no pair in V is redundant. 2.4.2 Assigning unverified comparisons. We now define findWset. First, we bound the number of agents each comparison must be assigned to in order to retrieve the ground-truth sorting. Details about the social golfer problem. In the social golfer problem, the goal is to determine whether m golfers can play together in g groups of p (where m = gp) for w days in such a way that (1) no two golfers play in the same group more than once, and (2) each golfer plays exactly once each day. Thus, an instance of this problem is defined by integers (g, p, w). For us, the golfers correspond to the items, the days correspond to the partitions, and the groups of golfers correspond to the sets in the partitions. Thus, we aim to solve this problem with g, p, and w all approximately equal to √n. 2.5 Principal’s incentives We synthesize our results in the following theorem, in which we additionally prove that if the principal’s disutility ψ¯ is sufficiently larger than the agents’ disuility ψ, then it is in the principal’s best interest to use our mechanism rather than perform all pairwise comparisons herself. This is a natural assumption, which implies that the principal would have to be compensated sufficiently more per comparison than the agents for their work to be profitable to the principal. This paper is available on Arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. Authors: (1) Kiriaki Frangias; (2) Andrew Lin; (3) Ellen Vitercik; (4) Manolis Zampetakis. This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Kiriaki Frangias; (2) Andrew Lin; (3) Ellen Vitercik; (4) Manolis Zampetakis. Table of Links Abstract and Introduction Abstract and Introduction Warm-up: Agents with known equal disutility Warm-up: Agents with known equal disutility Agents with unknown disutilites Agents with unknown disutilites Experiments Experiments Conclusions and future directions, References Conclusions and future directions, References A Summary of notation A Summary of notation B Omitted proofs from Section 2 B Omitted proofs from Section 2 C Omitted proofs from Section 3 C Omitted proofs from Section 3 D Additional Information about Experiments D Additional Information about Experiments 2 Warm-up: Agents with known equal disutility As a warm up to our main result, in this section, we propose a contract assuming that (a) the principal knows the agents’ disutilites and (b) every agent experiences the same value of per-comparison disutility (assumptions we relax in Section 3). We begin with a formal model in Section 2.1 and define the optimal payment in Section 2.2. In Sections 2.3 and 2.4, we present our main algorithm CrowdSort for computing the correct sorting. Section 2.5 identifies conditions under which the principal gets higher utility when implementing our proposed contract than when performing all pairwise comparisons herself. The full proofs of all results in this section are in Appendix B. 2.1 Model and notation The interaction proceeds as follows: 1. The principal fixes a payment p∗ ∈ R+ that she will pay agents in order to incentivize them to exert effort. 2. The principal verifies a subset of the comparisons and announces the size of this set to the agents. 3. Agents choose whether to exert effort, which fixes their type upfront. 4. Agents are assigned verified and unverified comparisons. 2.2 Agents’ incentives 2.3 Peer grading algorithm 2.4 Allocation of items 2.4.1 Assigning verified comparisons. Lemma 2.3. If each item in V appears in exactly one pair, then no pair in V is redundant. Lemma 2.3. If each item in V appears in exactly one pair, then no pair in V is redundant. 2.4.2 Assigning unverified comparisons. We now define findWset. First, we bound the number of agents each comparison must be assigned to in order to retrieve the ground-truth sorting. Details about the social golfer problem. In the social golfer problem, the goal is to determine whether m golfers can play together in g groups of p (where m = gp) for w days in such a way that (1) no two golfers play in the same group more than once, and (2) each golfer plays exactly once each day. Thus, an instance of this problem is defined by integers (g, p, w). For us, the golfers correspond to the items, the days correspond to the partitions, and the groups of golfers correspond to the sets in the partitions. Thus, we aim to solve this problem with g, p, and w all approximately equal to √n. Details about the social golfer problem. 2.5 Principal’s incentives We synthesize our results in the following theorem, in which we additionally prove that if the principal’s disutility ψ¯ is sufficiently larger than the agents’ disuility ψ, then it is in the principal’s best interest to use our mechanism rather than perform all pairwise comparisons herself. This is a natural assumption, which implies that the principal would have to be compensated sufficiently more per comparison than the agents for their work to be profitable to the principal. This paper is available on Arxiv under CC 4.0 license. Arxiv Arxiv

Algorithmic Contract Design for Crowdsourced Ranking: Warm-up: Agents With Known Equal Disutility

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 部分：对话式

Agents are typically processing units used to execute a task within a job. They receive execution details from the server in the form of configuration and then execute those sets of steps. This software pattern is used widely today by a lot of applications. For instance build, test and deploy tooling like Azure DevOps, Jenkins, buildkite etc. These are typically either available as SaaS or on premise installation. These tools let you build, test, deploy your software and/or configuration continuously. Now these tooling services need their own set of services/hardware to ensure it can run the pipelines. Here is the high level architecture diagram: When you push your code, a build job creation request is sent to the CICD server. The CICD server will select an agent from pools of agents, and assign the job to it. The CICD server acts as an orchestrator, its responsibility is to schedule jobs for the agents, keeping track of jobs, retrying failed jobs, rescheduling jobs on agent failure etc. An agent is a machine or a container that executes the job. These agents are often hosted on different OS. Agents can be ephemeral or persistent. Based on the job definition, an agent with the appropriate OS will be selected. This detached architecture makes scalability easier, new agents can be easily added to scale up the build system. How does a controller select an agent? The agents would poll for the next available job from the controller. The controller would assign the job in First in First Out (FIFO) order for the matching agent. If you specify an agent to a particular job, it will wait for the specific agent to become available. If the job is labeled to select agents to match for parameters like the OS and/or particular .NET version/ simulator or databases, the controller would wait for the agent with such configurations to become available. Types of agents : When persistent agents are created, they register themselves with the controller and are added to the agent pool. These agents would then periodically poll for jobs. Once it receives a job, it would execute the job and return job status to the server. Persistent agents Persistent agents can be configured to preserve workspace data between builds. This can speed up the build process. But it can not always be guaranteed. Even if you configure your agents to persist data, the controller can not guarantee to select the same agent for an incremental build or for a different stage in the same build. Additionally there is some level of security risk involved with persistent agents. If one of the jobs infected the agent all the subsequent jobs executed on that agent will be infected. Additional care should be taken that no private information is stored on the agent as it will be shared for subsequent sets of jobs. : Some devops solutions allow you to use ephemeral agents of the VM image or container image you provide. Some devops tooling allows these containers to be spun up onto kubernetes or a small binary executing on VM that can spin up containers for job execution. These agents are discarded after the job finishes. Since these are ephemeral they have to download your source code, dependent binaries and tooling for each job execution this latency will add on to job execution time. These can not be used for incremental builds. With these agents the cloud service provider will manage the infrastructure for you. It can scale up depending on the load. Ephemeral agents Now we know what agents are, lets see different ways to configure them for better performance: Agents can be labeled based on their configuration Windows/Linux/Mac-OS or JDK version and also deploy/build/test etc. You can customize each agent based on their intended role. A build agent would need a version control system, compiler and runtime environment. A dedicated build agent will not be running tests so we do not need testing tools or browsers (if it runs UI testing) installed on them. Keep the relevant software installed and assign hardware based on need. Configure and label based on their role: Once you have separated agents based on their role, assign jobs to relevant agents. By making sure your Windows build job which needs MSBuild go to an agent labeled [OS : Windows, runtime: MSBuild] improves performance as it will have most of the dependencies installed and ready to go. Same applies for a Selenium test job routing to an agent which has a browser installed. Assign jobs to relevant agents: If your build jobs are taking more time than test jobs then consider adding agents in the build pool. If you can’t add extra hardware then analyze other pools and move a few agents from other lightweight pools to build pools. Monitor performance: For persistent agents, you have to ensure that regular maintenance is being performed and the OS/Softwares are patched. Maintenance: These steps mainly apply for build tools where you manage the agents. If you use ephemeral agents, it becomes challenging. In such a case you want to look closely in pipelines and workspace settings to optimize it. Some additional best practices for agents: Over a long run persistent agent can run out of disk space. Setting a retention policy for agents would save us from that risk. Agents typically delete old jobs and save disk space. Set up retention policy: Build, Test and Release tooling should work on injection principle. Its dependency should be injected into it rather than querying. This will help reduce the attack vector as well as make it easier to migrate tooling. Inject parameters: Polling typically creates additional overhead and resource wastage. Try to use event driven architecture for build, test and release triggers. Avoid polling: Don’t put large binary files in your source code, use blobs or package management. Every build, test and release don't need these files. They can be downloaded on demand. Don't put large binary files in source repository: Smart caching will help build times and test times. Use cache whenever possible but careful not to cache any secret and add some cache validation mechanism to protect from attacks. Use caching: Since agents perform critical tasks it is important to secure them. Occasionally antivirus software might provide false alarms for test and build output as viruses. Continuous careful auditing of these binaries should be performed with help of your security team. Use antivirus software on agents: Conclusion: Agents are an integral part of the build system. Selecting agents can play a huge role in performance of your end to end build, test and release pipeline. Understanding agents and how they play a part in the build system would help you design your pipelines more efficiently. These suggestions can be applied based on careful analysis of your system requirements.

Optimizing Agents In Devops Architecture 

Did you know that we have certain kinds of vending machines in the crypto world too? They were designed to facilitate users' experience in various operations involving trading —of any kind of token or physical product. as the product itself or as the payment method. In other words, you could use them or even create them to buy and sell something, including cryptocurrencies in the process Several companies have built and installed crypto-related physical vending machines in numerous cities worldwide. However, not every “vending machine” in crypto is physical. We also have digital vending machines to improve our experience. Let’s learn more about them. Physical Vending Machines + Crypto , the company American Green was likely the first one to build a Bitcoin-payment-friendly vending machine. To dispense medical marijuana. Due to the nature of the product, the machine also could scan IDs before the purchase, paid with BTC. Back in 2014 Different products and brands would join over the years: Today, it’s even possible to configure regular vending machines, to accept several cryptocurrencies, with the app . The product inside would depend solely on the owner(s). to buy beer, (with Litecoin), soft drinks, and much more. Red Bull snacks, PayRange , a new crypto vending physical machine would appear. This time, the tokens weren’t the payment method, but the product. Neon Marketplace created the first-ever vending machine to sell Non-Fungible Tokens (NFTs) physically; and installed it in New York (USA). They offered two collections in the Solana chain: “Colors” and “Party Pidgeons,” payable by credit card instead of cryptocurrencies. After 2022 The users would receive a small package containing a code to redeem their $6 or $421 prize. , the package could get stuck in the machine (like in any other vending machine) or the code may be defective. However, it’s considered a beginner-friendly way to start in the crypto world. Sometimes , including myNFT (London), Masahide Matsuda (Tokyo), Atlas (Malaysia), and the (Vancouver). Often, it would be possible to pay in crypto as well, and the machine would stay in place indefinitely. Some other times, this would be just a temporary exhibition at a crypto-related conference or art display. Other companies and artists would follow the example and create their own NFT vending machines Skull Society Digital Dispensers In 2019, even before the physical versions, a developer recreated the same vending machine process to buy and sell tokens digitally. It was a program inside the Bitcoin-based Counterparty Network, called “Dispenser,” and released by John "Chiguireitor" Villar through the Counterparty Improvement Proposal 21 ( ). CIP21 Unlike their physical counterparts, these virtual machines are accessible through websites or mobile/desktop applications, presenting the digital item, its quantity, price, and other pertinent details. Basically, a dispenser in Counterparty is a virtual vending machine, akin to its physical counterpart but instead of doling out sodas, it dispenses digital objects (NFTs or other compatible tokens). Dispensers provide a simple yet efficient mechanism for both creation and use. To create one, a seller requires some compatible assets (created with Counterparty) and configures the virtual dispenser to deliver a desired quantity of tokens at a specified price. Users, on the other hand, access dispensers through direct links, explore available options, and make purchases by sending the exact amount to the provided address, receiving the acquired NFTs promptly. BTC . Dispensers are still based in Bitcoin, though, so the transactions will always depend on the miners —some sort of middlemen. This user-friendly process eliminates intermediaries, making dispensers an accessible and cost-effective solution for digital item exchange within the Counterparty ecosystem They’re not smart contracts that mediate between users, but a digital entity by themselves, working independently after the first configuration and until the product is sold out. Another potential issue lies there, though: if the product (the asset) is sold out, and the user isn’t paying attention, they could lose all the funds sent to the dispenser. Autonomous Agents (AAs) There is another kind of crypto-related “vending machine,” but this one is more versatile than the others. Similar to smart contracts, in Obyte are computer programs, built with code on a distributed ledger. They’re designed to make a specific (and digital) task, but they’re not there to represent a real human “party,” user, or company. Autonomous Agents Smart contracts can enforce some pre-set conditions of any accord between users, while Autonomous Agents are a kind of “users” themselves. Just like vending machines, only that they have an unalterable code and can’t issue a wrong order or get stuck. Automated users, always available to carry on a specific task at the call of a human user. AAs receive transactions with money and data, delivering a response—monetary tokens and recorded data on the Directed Acyclic Graph (DAG) ledger, free of miners and other middlemen, which makes it more decentralized than other networks. They operate independently, transparently displaying expected responses in the same wallet before completing the transaction. Developed in Oscript, a programming language optimized for safety, AAs enable precise execution of tasks, minimizing errors. They serve various purposes: from decentralized exchanges and payment channels to prediction markets and lending apps. So, anyone can interact with the involved Dapp by sending or receiving transactions to and from the AA’s Obyte address. Users can interact with AAs through their , initiating transactions that are promptly recorded and answered. Obyte wallets Developers can also build their own AAs for different purposes, using the . Some AAs that are deployed on Obyte include the Dapp , the DEXes and , the , the prediction markets platform , and — a tool for cascading donations on GitHub. proper tools Bonded Stablecoins ODEX Oswap Obyte Token Registry Prophet Kivach What to choose? This is entirely up to you, of course. However, we have to admit that NFT machines, crypto-accepting machines, and digital dispensers (of tokens) have very limited and specific functions, while AAs could be any decentralized tool in the digital realm. For beginners, physical vending machines that accept or dispense cryptocurrencies offer tangible, real-world products with the convenience of digital currency transactions. These are suitable for those seeking a bridge between the digital and physical realms. Counterparty dispensers, functioning on the Bitcoin ledger, cater to the NFT market and token trading limited to this network. Autonomous Agents in Obyte present a digital, decentralized alternative, excelling in executing rule-based processes for various DeFi applications and beyond. They offer transparency, security, and user-friendly interactions, and could reach several chains if the users bridge their tokens through . Counterstake As we’ve mentioned above, many interesting applications in Obyte are built with AAs, but they have their own websites with user-friendly interfaces. You’ll just need your wallet and some coins. Ready to try? And remember, you don’t even have to know what an Autonomous Agent is . to use one Featured Vector Image by vectorjuice / Freepik

Exploring Crypto ‘Vending Machines’: Physical Machines, Dispensers, and Autonomous Agents

ক্রিপ্টো 'ভেন্ডিং মেশিন' অন্বেষণ করা: ফিজিক্যাল মেশিন, ডিসপেনসার এবং স্বায়ত্তশাসিত এজেন্ট

Erkundung von Krypto-„Verkaufsautomaten“: physische Maschinen, Spender und autonome Agenten

Explorando las 'máquinas expendedoras' de criptomonedas: máquinas físicas, dispensadores y agentes autónomos

Explorer les « distributeurs automatiques » cryptographiques : machines physiques, distributeurs et agents autonomes

क्रिप्टो 'वेंडिंग मशीन' की खोज: भौतिक मशीनें, डिस्पेंसर और स्वायत्त एजेंट

暗号通貨の「自動販売機」の探求: 物理マシン、ディスペンサー、自律エージェント

암호화폐 '자판기' 탐색: 물리적 기계, 디스펜서 및 자율 에이전트

Explorando ‘máquinas de venda automática’ criptográficas: máquinas físicas, distribuidores e agentes autônomos

Изучение криптовалютных «торговых автоматов»: физические машины, диспенсеры и автономные агенты

Kripto 'Otomat Makinelerini' Keşfetmek: Fiziksel Makineler, Dağıtıcılar ve Otonom Aracılar

Khám phá 'Máy bán hàng tự động' tiền điện tử: Máy vật lý, Máy phân phối và Đại lý tự trị

探索加密“自动售货机”：物理机器、分配器和自主代理

Scientific American Supplement, No. 711, August 17, 1889, by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . WATER AS A THERAPEUTICAL AGENT. here WATER AS A THERAPEUTICAL AGENT. By F.C. Robinson, M.D. My experience in the use of water in almost every disease occurring in this climate has long since satisfied me that it is less objectionable and produces quicker and better results than any other treatment, and can be used when all other medication is contra-indicated. Drinking water should be pure, uncontaminated by animal or vegetable impurities, and given , unless, in rare instances, it should cause vomiting or interfere with the capability of digesting food. If children are comatose or delirious, as they frequently are in typhoid fever, give water to them regularly, or force it upon them, if they refuse to take it, as I was obliged to do with a child of six years just recovering from that fever. ad libitum It is my custom to allow cold drinks of water in all cases of measles whenever patients desire it, and I am satisfied that it aids the early appearance of the rash, and certainly is cooling and grateful to the patient. Hot drinks or vile and nauseous teas are unnecessary in this disease, and should be discarded as useless, odious, and disgusting. If congestion of the lungs or any intercurrent inflammation occurs, or the rash is much delayed, a hot water bath or the old reliable corn sweat will break up the complication with amazing rapidity, and if the head is kept cool, will not generally be unacceptable to the patient. Hot baths reduce temperature by causing free perspiration afterward, and cold packs reduce it by cooling the surface sufficiently long to reduce the heat of the blood, and, if used judiciously, seldom fail of success. I have reduced the temperature four degrees in two hours by wrapping around a child a sheet wet with tepid water, and no other covering. Cold packs are sometimes objectionable, because of their depressing effects, and should only be used to reduce high temperature and when there is no congestion or inflammation of any of the vital organs of the body. Cold water poured in a small stream from a pitcher upon the head for five or ten minutes will often relieve headache, and is a benefit in all inflammatory brain diseases, if, at the same time, you can put the feet into hot water containing mustard or pepper. Large enemas of warm water will care for spasmodic colic, and I have, in one instance, relieved strangulated hernia by the same method, and at another time the same result was accomplished by a large injection of warm linseed oil. I have often applied a cloth wet with cold water upon the throats of children suffering with spasmodic croup, with satisfactory results. I have seen infants suffering with diarrhea or summer complaint, sleepless, worrying, fretting, or crying from thirst, begging for water, and the mother or nurse afraid to give it more than a teaspoonful or two at a time, saying that it vomited everything it drank as soon as taken. I have often, when visiting such cases, called for a glass of cold water, and, to the surprise of the mother, would allow it to take all it could drink, which usually would be retained, and the child would soon be wrapped in a refreshing sleep. Without medicine, a proper regulation of the child's diet would soon restore it to health again. The spasms of children, from whatever causes, or the eclampsia from uræmic poisoning, are often readily controlled when immersed in hot water or given a hot vapor bath or corn sweat. If the convulsions of children are accompanied by a high temperature, put them into water of 100° and then gradually cool it down to 68° or 70°, and then keep them in a room of the same temperature, with little covering. If the temperature rises, repeat the treatment as frequently as necessary, and I think you will not be disappointed in the results. Scarlet fever and diphtheria, two of the most dreaded and formidable diseases of children, are largely shorn of their terrors when, in addition to an early and thorough medicinal treatment, the little patients are bathed in as warm water as the surface will allow frequently, or for thirty minutes wrapped in a warm, wet blanket, followed by warm, dry coverings, to maintain the perspiration that such treatment usually produces. It has proved to me a valuable aid in eliminating from the blood the specific poison which causes these diseases, and I can safely recommend it to your notice and trial. There is no disease more favorably influenced by this treatment than pneumonia, and in mild cases one daily warm bath or sweat, without medicine, will be sufficient to arrest this disease, and it is among the first things I usually order. If I find a child or infant with a temperature of 103° to 105°, short, dry, and painful cough, dyspnœa, rapid pulse, great thirst, or vomiting, with dry crepitation in any part of the lung tissue, I order it rolled up in a blanket or sheet coming out of hot water, and in thirty minutes change it to warm, dry blankets, and soon the little fretful, worrying sufferer would rest in a quiet, peaceful sleep.— Peoria Med. Mo. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various (2004). Scientific American Supplement, No. 711, August 17, 1889. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/16972/pg16972-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

WATER AS A THERAPEUTICAL AGENT

In today's digital world, having a strong online presence is crucial for the success of any business. However, navigating the complex world of digital marketing can be overwhelming, especially for those who are not familiar with the latest trends and strategies. This is where a digital marketing agency can be a game-changer for your business. But with so many agencies out there, how do you choose the right one? In this article, we will guide you through the process of selecting an outstanding digital marketing agency that aligns with your business needs and goals. 1. Identify Your Business Needs and Goals Before you can start searching for a digital marketing agency, it is essential to understand what your business needs and goals are. Take the time to analyze your current marketing efforts and identify areas where you need assistance or improvement. At this stage, the most important question to ask yourself is as to whether you are looking to increase brand awareness, drive more traffic to your website, generate leads, or boost conversions. Understanding your specific objectives will help you find an agency that specializes in the areas you need help with. 2. Research and Compare Different Agencies Once you have a clear understanding of your business needs and goals, it is time to start researching and comparing different digital marketing agencies. Make use of search engines, social media platforms, and industry forums to find agencies that operate in your niche or industry. In this case,you might want to look for agencies that have a proven track record and a strong online presence themselves. Pay attention to their website, blog, social media profiles, and client reviews. This will give you a good sense of their expertise and professionalism. 3. Evaluate Their Experience and Expertise When evaluating digital marketing agencies, it is important to consider their experience and expertise in your specific industry. Finding agencies that have worked with businesses similar to yours and have achieved measurable results for their clients can make all the difference . Hence, it is crucial to consider how long the agency has been in business and the number of successful campaigns they have executed. An agency that is well-versed in your industry will have a better understanding of your target audience and how to effectively engage them. 4. Review Their Portfolio and Case studies A reputable digital marketing agency should be able to provide you with a portfolio and case studies showcasing their past work and successes. You might want to spend time reviewing these materials to get a sense of the agency's creativity, innovation, and problem-solving abilities. In searching for clues endeavour to focus on case studies that clearly demonstrate how the agency was able to overcome challenges and achieve tangible results for their clients in the past. This will give you confidence in their ability to deliver on your own objectives. 5. Consider Communication and Collaboration Effective communication and collaboration are essential tools for a successful partnership with a digital marketing agency. During the selection process, it is important to pay attention to how responsive and approachable the agency is. It's essential to ask questions about their communication protocols and processes to ensure that you have regular updates and open lines of communication when you need them . Additionally, you must consider their willingness to collaborate and understand your unique business needs. Best to understand that an agency that is willing to listen to your ideas and work with you as a trusted partner is crucial to have. 6. Evaluate Pricing and Return on Investment (ROI) Budget is a crucial consideration in choosing a digital marketing agency. It's important to find an agency that can work within your budget while still delivering results. However, it's equally important to evaluate the potential return on investment (ROI) that the agency can offer. Endeavour to avoid making the mistake of choosing the cheapest agency without considering the value and expertise they bring to the table. A reputable agency may charge a premium price, but their experience and track record may yield a higher ROI in the long run. Conclusion Choosing the right digital marketing agency for your business is a critical decision that can have a significant impact on your online presence and overall success. By identifying your business needs and goals, researching and comparing different agencies, evaluating their experience and expertise, reviewing their portfolio and case studies, considering communication and collaboration, and evaluating pricing and ROI, you can make an informed decision that will benefit your business in the long run. It is important to remember that a successful partnership with a digital marketing agency can help you reach new heights and achieve your objectives in the ever-evolving digital landscape.

How To Choose The Right Digital Marketing Agency For Your Business

Embark on a cosmic journey with Coinband, a leading Web 3.0 marketing agency. Specializing in community development, influence marketing, and more, Coinband propels projects to stellar heights. Intro One of the main issues within the Web 3.0 environment is that such products are really complex for many users. Coinband is a space crew of Web 3.0 marketing enthusiasts who simplify complex things. They deliver attractive and clear packaging and maintain proper marketing communications with the right audience to achieve the best ROI. Exploring the Vast Universe of Coinband's Expertise In the ever-evolving landscape of Web 3.0, navigating the cosmos of marketing requires a seasoned guide. Enter Coinband, a stellar agency founded in 2022 by crypto marketing luminaries with four years of expertise. Having propelled more than 50 Web 3.0 projects to success, Coinband stands as an industry leader in the cryptocurrency and blockchain sectors. The examples of bright can be regarded as proof of this statement. cases Mission Control: Coinband's Specialization Coinband is not just a marketing agency; it is the mission control for your Web 3.0 project's journey. Specializing in delivering first-rate marketing solutions, Coinband ensures your project not only survives but thrives in the competitive space of Web 3.0. The band members always keep their noses in the wind and their eyes along the skyline. The agency's crafts advanced growth strategies, providing an unparalleled client experience that elevates your project above the stars. expert team Coinband's array of services defy the conventional, showcasing a commitment to innovation and excellence. From community development to website design, the agency's toolkit is designed to elevate your project to new heights. Community Development: Galaxies Unite In the vast expanse of Web 3.0, creating and managing communities is paramount. Coinband excels at forging connections, using platforms like Discord and Telegram to unite like-minded individuals. These communities not only share a common goal but also foster communication, interaction, and engagement. Influence Marketing: Stellar Partnerships In the cosmic dance of social networks, Coinband leverages influence marketing to attract influencers who can propel your project to the forefront. With a database boasting 300 proven crypto-influencers, the agency crafts scenarios that transform opinion leaders into advocates for your project. Paid Ads and SEO: Navigating Celestial Sea Launching advertising campaigns and optimizing for search engines, Coinband sails through the celestial sea of paid ads and SEO. Whether it is targeted advertising on social networks or reaching the first position in organic search results, the agency ensures your project shines brightly in the digital cosmos. PR: Crafting Constellations of Recognition Public relations acts as the constellation that distinguishes your project from the cosmic crowd. Coinband utilizes media relations to create a positive image and reputation, impacting brand recognition, trust, and attitude within the crypto community. Website Development: Designing Constellations A website is more than a digital outpost. It is a constellation embodying your brand's big idea. Coinband's website development service not only creates visually stunning designs but also integrates essential functionalities and analytics. Cosmic Partnership Awaits In the vast galaxy of Web 3.0, Coinband emerges as a reliable partner, ready to propel your project to the stars. If you seek a marketing agency that understands the nuances of the decentralized cosmos, look no further. Coinband is not just a digital advertising agency. It is the launchpad to success in the Web 3.0 universe. Reach for the Stars With Coinband Ready to embark on a cosmic journey of success and walk down the yellow brick road? Explore Coinband's at the and contact the agency for a consultation. Your project's destiny in the Web 3.0 galaxy awaits – seize it with Coinband. services official website Coinband is your green light to shortcut the journey from a startup to a unicorn project.

Unlocking Cosmos: Coinband Agency Propels Your Web 3.0 Project to Stardom

কসমস আনলক করা: কয়েনব্যান্ড এজেন্সি আপনার ওয়েব 3.0 প্রজেক্টকে স্টারডমের দিকে এগিয়ে নিয়ে যায়

Den Kosmos freischalten: Die Agentur Coinband macht Ihr Web 3.0-Projekt zum Star

Desbloqueando el cosmos: la agencia Coinband impulsa su proyecto Web 3.0 al estrellato

Déverrouiller le cosmos : l'agence Coinband propulse votre projet Web 3.0 vers la célébrité

अनलॉकिंग कॉसमॉस: कॉइनबैंड एजेंसी आपके वेब 3.0 प्रोजेक्ट को स्टारडम की ओर ले जाती है

コスモスのロックを解除: Coinband Agency が Web 3.0 プロジェクトをスターダムに押し上げる

Cosmos 잠금 해제: Coinband Agency, Web 3.0 프로젝트를 스타덤으로 추진

Desbloqueando o Cosmos: Agência Coinband impulsiona seu projeto Web 3.0 ao estrelato

Открытие Cosmos: агентство Coinband продвигает ваш проект Web 3.0 к славе

Cosmos'un Kilidini Açmak: Coinband Ajansı Web 3.0 Projenizi Yıldızlığa Taşıyor

Mở khóa Cosmos: Cơ quan Coinband đẩy dự án Web 3.0 của bạn trở thành ngôi sao

解锁 Cosmos：Coinband Agency 推动您的 Web 3.0 项目走向明星

The New Age of Talent Management As influencers become the new face of stardom in this era of digital transformation, talent management agencies are racing to tailor their approaches to the demands of these online pioneers. Leading this shift is , the brainchild of Eric Kullberg, Erika Kullberg, and Apple Crider. Their focus isn't just on offering traditional services such as securing sponsorships. Creators Agency Instead, they're establishing a unique niche, striving to connect creators with broad-ranging opportunities, aiming at lasting affiliations over short-term engagements. At its heart, Creators Agency prides itself on the depth of the relationships it cultivates. Building More than Just Transactions: The Relationship Aspect Creators Agency, according to some accounts, emphasizes the significance of relationships in its business model. It's not just about transactional interactions but more about building long-term rapport. Kevin, a talent manager at Creators Agency, shared his experience, stating that some of his interactions with creators feel more like casual conversations than business meetings. He recalls unique experiences, from group outings in Japan to karaoke sessions in Tokyo streets. However, it's essential to understand that this might not be everyone's experience, but it does hint at a potentially different approach to talent management. The Learning Curve: Growth Opportunities at Creators Agency Learning and personal growth opportunities are cited as other attractions for those who work at Creators Agency. Kevin, who had minimal sales experience before joining, feels that being surrounded by a motivated team accelerated his learning curve. Such an environment, while beneficial, also demands a high level of commitment and self-motivation. While the agency promotes itself as a hub for high-achievers, prospective employees should weigh if they align with this dynamic, fast-paced ecosystem. Embracing Modern Work Culture: Flexibility and Balance Flexibility in work culture is becoming increasingly important, and the Creators Agency seems to be riding this wave. The emphasis on remote work and a non-rigid work environment does make it appealing, especially for those looking for a work-life balance. However, a flexible environment also necessitates self-discipline and clear communication, factors that potential talent managers should be prepared for. A Unique Perspective: "For Creators, By Creators" A notable feature Kevin highlighted about Creators Agency is its orientation — "for creators, by creators." This suggests that the agency might have an insider's perspective on the challenges and aspirations of digital content creators. But it also raises a question: Does this model offer a more in-depth understanding, or does it create an echo chamber? It's a point for stakeholders to consider. Balancing Work and Fun: The Agency's Approach The agency's proclaimed "work hard, play hard" mentality might resonate with many, especially in a generation that values experiences as much as, if not more than, material gains. Creators Agency seems to be able to successfully incorporate “work hard, play hard” into their culture. Traveling for work and team building trips appear to be a common theme in their company. A Singular Journey: Kevin's Experience Kevin's personal journey, while insightful, is a singular narrative. His experiences, ranging from professional communication, sales, and contract negotiation, to creative brainstorming and performance marketing, are undoubtedly valuable. Yet, every individual's journey will be different, shaped by their goals, background, drive, and interactions. Redefining Talent Management: A Holistic Look at Creators Agency In a nutshell, Creators Agency appears to be redefining talent management in the digital age. Its emphasis on relationships, flexibility, and a dynamic work environment are commendable. However, like all businesses and workplaces, it comes with its own set of challenges and might not be a perfect fit for everyone. For those eyeing a career in digital talent management or content creators seeking representation, it might be worth considering as an option, but as always, due diligence and a thorough understanding of one's own requirements are paramount. Creators Agency

Creators Agency Ranked as One of the Best Talent Agencies to Work For

ক্রিয়েটর এজেন্সি কাজ করার জন্য সেরা প্রতিভা সংস্থাগুলির মধ্যে একটি হিসাবে স্থান পেয়েছে৷

Die Creators Agency wurde als eine der besten Talentagenturen eingestuft, für die man arbeiten kann

Agencia de creadores clasificada como una de las mejores agencias de talentos para trabajar

Creators Agency classée parmi les meilleures agences de talents pour lesquelles travailler

क्रिएटर्स एजेंसी को काम करने के लिए सर्वश्रेष्ठ प्रतिभा एजेंसियों में से एक के रूप में स्थान दिया गया है

Creators Agency が働きやすい人材派遣会社の 1 つとしてランクイン

크리에이터스 에이전시, 일하기 가장 좋은 인재 에이전시로 선정

Agência de criadores classificada como uma das melhores agências de talentos para se trabalhar

Creators Agency признано одним из лучших агентств по работе с талантами

İçerik Oluşturucu Ajansı Çalışılacak En İyi Yetenek Ajanslarından Biri Seçildi

Creators Agency được xếp hạng là một trong những cơ quan tài năng tốt nhất để làm việc cùng

Creators Agency 被评为最适合工作的人才机构之一

Deploying multiple local Ai agents using local LLMs like Llama2 and Mistral-7b. “Never Send A Human To Do A Machine’s Job” — Agent Smith Are you searching for a way to build a whole army of organized ai agents with Autogen using local LLMs instead of the paid OpenAi? Then you came to the right place! Chat LLMs are cool, but giving taking action as an intelligent agent is next level. What about many of them? Meet Microsoft’s latest project. Autogen But there is a problem. Autogen was built to be hooked to OpenAi by default, wich is limiting, expensive and censored/non-sentient. That’s why using a simple LLM locally like is the best way to go. You can also use with any other model of your choice such as , , , , the sky (your hardware) is really the limit. Mistral-7B Llama2 Falcon Vicuna Alpaca The secret is to use openai JSON style of output in your local LLM server such as Oobabooga’s text-generation-webui, then hook it to autogen. That’s what we’re building today. Note there are other methods for making llms spit text in openai apis format as well like the llama.cpp python bindings. 0. Getting Oobabooga’s text-generation-webui, an LLM (Mistral-7b) and Autogen In this tutorial we will be: Setting up OpenAi format extension on Oobabooga Starting the local LLM server with the OpenAi format Hooking it to Autogen Let’s get started! 0. Getting Oobabooga’s Text-Generation-Webui, an LLM (Mistral-7b) and Autogen Before proceeding, it’s recommended to use a virtual environment when installing pip packages. Make a new one and activate it if you feel like. This is a well known program for hosting LLMs in your local machine. Head to and follow the installation guide. It is very straight forward to get started. You might also want to download if you are using an NVIDIA gpu for acceleration. Getting Obbabooga’s Text Generation Webui: text-generation-webui’ s page CUDA After downloading the text generation webui, don’t start it just yet. We need to get a LLM to give life to our agents. Getting an LLM (Mistral-7b-Instruct): Today we’ll be exploring , specifically , an optimized version of the model by TheBloke. You can choose the optimized model perfect for your machine based on the . Mistral-7B Mistral-7B-instruct-v0.1.Q4_K_S.gguf explanation in the description You can choose smaller or bigger models depending on your hardware. Don’t be too scared to try out things in your computer tho, we’re making science here. Head to the , and grab the following: Files and Versions page config.json (will run well in most mid setups) Mistral-7B-instruct-v0.1.Q4_K_S.gguf Once downloaded, head to the text-generation-webui installation folder, and inside it . In there, with the name of your model (or any name you want), like . The path will be like this: open the models folder create a new folder “mistral-7b-instruct” C:/.../text-generation-webui/models/mistral-7b-instruct Place both the file and the in the new folder. config.json model.gguf : To install Microsoft’s multi-agent making python library just install it using the pip package installer in your terminal. Getting Autogen pip install pyautogen 1. Setting Up OpenAi Format Extension on Oobabooga With your brand new text-generation-webui installed and the LLM downloaded, we can proceed on making your local Oobabooga server speak in OpenAi JSON format. You can learn more about OpenAi APIs formats and features it in their . documentation To hook Autogen with our local server, we will need to activate the “openai” extension in the Ooobaboga’s text-generation-webui extensions folder. In your terminal head to folder and in there install its requirements: “text-generation-webui/extensions/openai” pip install -r requirements.txt 2. Starting The Local LLM Server In OpenAi Format Now head back to the root folder in your terminal. Its time to get this baby up and running. /text-generation-webui As the name says, it was meant to be used as a webui, but you can also just keep it running as a server to query apis from other programs you make. To boot it as a local server and with the openai api extension, use the following command according to your current OS. (In my case I named the folder **“**mistral-7b-instruct”) Don’t forget to change the “model” parameter to the folder name we created earlier at /models. Windows: ./start_windows.bat --extensions openai --listen --loader llama.cpp --model mistral-7b-instruct Linux: ./start_linux.sh --extensions openai --listen --loader llama.cpp --model mistral-7b-instruct MacOS: ./start_macos.sh --extensions openai --listen --loader llama.cpp --model mistral-7b-instruct We pass the parameter to load the extension, to start a server we can query from autogen, and wich specify the loader for the model and the model folder name we created earlier, with the config.json and the model.gguf files. extensions openai listen loader model If everything goes right, you might see something like this: The webui is running on your localhost port 7860 as an usual start, but note our OpenAI compatible api is also ready to be used by Autogen at our local host at . http://127.0.0.1:5001/v1 3. Hooking it to Autogen At this point, you already have the autogen lib installed, so it’s time to import it and plug our LLM server. Let’s start with something simple, a single agent interacting with a human (you). Create a new directory wherever you like, and add a new file there. You can also rename the file as you wish. autogen.py Generally to simply connect to OpenAi GPT’s API you would start the file like this: import autogen #start importing the autogen lib

config_list = [
    {
        'model': 'gpt-3.5-turbo',
        'api_key': 'your openai real key here'

    }
] But to use our running local server, we initiate it like this: import autogen #start importing the autogen lib

config_list = [
    {
        "model": "mistral-instruct-7b", #the name of your running model
        "api_base": "http://127.0.0.1:5001/v1", #the local address of the api
        "api_type": "open_ai",
        "api_key": "sk-111111111111111111111111111111111111111111111111", # just a placeholder
    }
] As you don’t need a real key for working locally, we are just using the sk-1111… placeholder. Next, we can setup the agent and the human user. Read the comments for better understanding. import autogen #start importing the autogen lib

config_list = [
    {
        "model": "mistral-instruct-7b", #the name of your running model
        "api_base": "http://127.0.0.1:5001/v1", #the local address of the api
        "api_type": "open_ai",
        "api_key": "sk-111111111111111111111111111111111111111111111111", # just a placeholder
    }
]

# create an ai AssistantAgent named "assistant"
assistant = autogen.AssistantAgent(
    name="assistant",
    llm_config={
        "seed": 42,  # seed for caching and reproducibility
        "config_list": config_list,  # a list of OpenAI API configurations
        "temperature": 0,  # temperature for sampling
        "request_timeout": 400, # timeout
    },  # configuration for autogen's enhanced inference API which is compatible with OpenAI API
)

# create a human UserProxyAgent instance named "user_proxy"
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10, 
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    code_execution_config={
        "work_dir": "agents-workspace", # set the working directory for the agents to create files and execute
        "use_docker": False,  # set to True or image name like "python:3" to use docker
    },
)

# the assistant receives a message from the user_proxy, which contains the task description
user_proxy.initiate_chat(
    assistant,
    message="""Create a posting schedule with captions in instagram for a week and store it in a .csv file.""",
) Remember to change message=”…” with your initial orders. If you just run the script with the message, you may see a new directory called “agents-workspace” with a .csv file in there, created “manually” by the agent. Now let’s go for something a bit more advanced. Multiple agents with roles and contexts. This will work like a “chat group” like any messaging app you know. Their contexts (system message) will tell them how to behave, and wich hierarchy they should obey. This time we will have: Two humans: the admin and the executor. Four agents: the engineer, the scientist, the planner and the critic. import autogen

#Use the local LLM server same as before
config_list = [
    {
        "model": "mistral-instruct-7b", #the name of your running model
        "api_base": "http://127.0.0.1:5001/v1", #the local address of the api
        "api_type": "open_ai",
        "api_key": "sk-111111111111111111111111111111111111111111111111", # just a placeholder
    }
]

# set a "universal" config for the agents
agent_config = {
    "seed": 42,  # change the seed for different trials
    "temperature": 0,
    "config_list": config_list,
    "request_timeout": 120,
}

# humans
user_proxy = autogen.UserProxyAgent(
   name="Admin",
   system_message="A human admin. Interact with the planner to discuss the plan. Plan execution needs to be approved by this admin.",
   code_execution_config=False,
)

executor = autogen.UserProxyAgent(
    name="Executor",
    system_message="Executor. Execute the code written by the engineer and report the result.",
    human_input_mode="NEVER",
    code_execution_config={"last_n_messages": 3, "work_dir": "paper"},
)

# agents
engineer = autogen.AssistantAgent(
    name="Engineer",
    llm_config=agent_config,
    system_message='''Engineer. You follow an approved plan. You write python/shell code to solve tasks. Wrap the code in a code block that specifies the script type. The user can't modify your code. So do not suggest incomplete code which requires others to modify. Don't use a code block if it's not intended to be executed by the executor.
Don't include multiple code blocks in one response. Do not ask others to copy and paste the result. Check the execution result returned by the executor.
If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.
''',
)

scientist = autogen.AssistantAgent(
    name="Scientist",
    llm_config=agent_config,
    system_message="""Scientist. You follow an approved plan. You are able to categorize papers after seeing their abstracts printed. You don't write code."""
)

planner = autogen.AssistantAgent(
    name="Planner",
    system_message='''Planner. Suggest a plan. Revise the plan based on feedback from admin and critic, until admin approval.
The plan may involve an engineer who can write code and a scientist who doesn't write code.
Explain the plan first. Be clear which step is performed by an engineer, and which step is performed by a scientist.
''',
    llm_config=agent_config,
)

critic = autogen.AssistantAgent(
    name="Critic",
    system_message="Critic. Double check plan, claims, code from other agents and provide feedback. Check whether the plan includes adding verifiable info such as source URL.",
    llm_config=agent_config,
)

# start the "group chat" between agents and humans
groupchat = autogen.GroupChat(agents=[user_proxy, engineer, scientist, planner, executor, critic], messages=[], max_round=50)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=agent_config)

# Start the Chat!
user_proxy.initiate_chat(
    manager,
    message="""
find papers on LLM applications from arxiv in the last week, create a markdown table of different domains.
""",
)

# to followup of the previous question, use:
# user_proxy.send(
#     recipient=assistant,
#     message="""your followup response here""",
# ) There you go, you have your new army of agents. I strongly recommend going deeper in the Autogen documentation to understand what else this kind of agency automation is able to do. Also, after understanding how autogen works under the hood you may want to use it via a interface like , or maybe create your own in your company’s dashboard. autogen-ui Now it’s up to you. Orchestrate agents untied from OpenAi limitations, to build a better future for us humans. Always remember that with great power comes great responsibility. So, what are you building next? This post was completely written by a human™ Also published . here

Beep Beep Bop Bop: How to Deploy Multiple AI Agents Using Local LLMs

বিপ বিপ বপ বপ: স্থানীয় এলএলএম ব্যবহার করে একাধিক এআই এজেন্ট কীভাবে মোতায়েন করবেন

Beep Beep Bop Bop: So stellen Sie mehrere KI-Agenten mithilfe lokaler LLMs bereit

Beep Beep Bop Bop: Cómo implementar múltiples agentes de IA utilizando LLM locales

Beep Beep Bop Bop : Comment déployer plusieurs agents IA à l'aide de LLM locaux

बीप बीप बोप बोप: स्थानीय एलएलएम का उपयोग करके एकाधिक एआई एजेंटों को कैसे तैनात करें

Beep Beep Bop Bop: ローカル LLM を使用して複数の AI エージェントをデプロイする方法

Beep Beep Bop Bop: 로컬 LLM을 사용하여 여러 AI 에이전트를 배포하는 방법

Beep Beep Bop Bop: como implantar vários agentes de IA usando LLMs locais

Beep Beep Bop Bop: как развернуть несколько агентов ИИ с помощью локальных LLM

Beep Beep Bop Bop: Yerel LLM'leri Kullanarak Birden Fazla Yapay Zeka Aracısı Nasıl Dağıtılır

Beep Beep Bop Bop: Cách triển khai nhiều tác nhân AI bằng LLM cục bộ

Beep Beep Bop Bop：如何使用本地 LLM 部署多个 AI 代理

Stories, News & Mentions about AGENTY

Agenty’s Stories on HackerNoon

Agenty's News & Mentions