With our tool dealers transform more unknown website visitors into appointments in store

Conversional

ChatGPT has taken over Twitter and pretty much the whole internet, thanks to its power and the meme potential it provides. We all know how being able to generate memes is the best way to conquer the internet, and so it worked. Since you’ve seen numerous examples, you might already know that ChatGPT is an , that you can chat with. It is also called a chatbot, meaning you can interact with it conversationally, imitatting a one-on-one human discussion. AI recently released to the public by OpenAI What you might not know is what it is and how it works... Watch the video to learn more! References ►Try it: ►OpenAI's blog post: ►What is GPT-3: ►What is Reinforcement Learning: ►Join our Discord community: ►Twitter: ►Support me on Patreon: https://chat.openai.com/ https://openai.com/blog/chatgpt/ https://youtu.be/gDDnTZchKec https://youtu.be/C5_NfQy_kZU https://www.louisbouchard.ai/learn-ai-together/ https://twitter.com/Whats_AI https://www.patreon.com/whatsai Video Transcript 0:00 you've seen it everywhere Chad GPT has 0:02 taken on Twitter and pretty much the 0:04 whole internet thanks to its power and 0:06 the meme potential it provides we all 0:08 know being able to generate memes is the 0:11 best way to conquer the internet and so 0:13 it worked since you've seen numerous 0:14 examples you might already know that 0:16 chatgpt is an AI recently released to 0:19 the public by openai allowing you to 0:21 chat with it it's also called a chatbot 0:24 meaning you can interact with it 0:25 conversionally imitating a one-on-one 0:28 human discussion what you might not know 0:30 is what it is and how it works 0:32 chadjupiti is a model based on 0:35 reinforcement learning and the GPT 0:37 series of models from openai I will 0:39 refer you to a video about reinforcement 0:41 learning we recently published with my 0:43 friend Elias to learn more about the 0:46 subfield of AI but quickly reinforcement 0:48 learning is a way to train algorithms by 0:51 trial and error aiming for rewards just 0:54 like humans would do by learning with 0:56 positive feedback more specifically chat 0:58 GPT was built following three steps the 1:02 first was to take an already powerful 1:04 model and fine tune it with supervised 1:06 learning what does this mean it means 1:08 that they took a model specifically its 1:11 GPT 3.5 and improved and up-to-date 1:14 version of gpd3 which they trained once 1:17 more on conversation examples 1:19 specifically instead of being trained on 1:21 pretty much their whole internet as gpt3 1:24 was this means they are trying to narrow 1:26 its potentials strictly to conversations 1:28 making it theoretically better at 1:31 conversing compared to gpt3 since a 1:34 specialist is almost always better than 1:36 a generalist at a specific task if you 1:38 are still not familiar with the GPT 1:40 series of models I would suggest 1:42 watching the short introduction video I 1:44 made covering gpt3 when it came out the 1:47 second step is to add our reinforcement 1:49 learning magic which will allow the 1:51 model to practice and get better as you 1:53 know practice makes perfect more 1:55 precisely in this step we will use the 1:57 model to chat with humans directly have 2:00 it provide multiple possible answers and 2:03 ask the human to rate the answers from 2:05 best to worst this data will then be 2:07 used to train another model called our 2:10 reward model learning to replicate our 2:12 human annotators this leads to our last 2:15 step where our new reward model will 2:18 give feedback to the chat GPT model's 2:20 answers as a reward function to help it 2:22 converge toward the best answers over 2:24 time this final step is to further train 2:27 our algorithm after the initial fine 2:30 tuning step we explained this is why it 2:32 is companies like open AI that release 2:34 those kinds of amazingly powerful models 2:37 it will be unfeasible for universities 2:39 or individuals as it requires way too 2:42 much Computing and time for training 2:44 still what they achieve is quite 2:46 remarkable and I believe they are worth 2:48 doing and worth sharing to Advent 2:50 science and voila after coupling the 2:54 already powerful and most recent GPT 2:56 based language model fine-tuning it to 2:59 conversations and finally using 3:01 reinforcement learning to make it 3:03 practice its conversation skills you 3:05 obtain chat GPD as you have seen before 3:07 the model is quite promising but also 3:10 sometimes a very dumb and doesn't seem 3:12 to have any logic whatsoever it is still 3:15 just an algorithm and far from being 3:17 either intelligent or conscious though 3:20 it will depend on how we Define both it 3:22 definitely has its limitations 3:24 nonetheless the outputs it gives are 3:27 often surprisingly interesting and 3:29 pertinent chatgpt is definitely a step 3:31 forward in conversational Ai and quite 3:34 promising especially working on the 3:36 prompt engineering side of the model to 3:38 leverage its true potential and limit 3:41 failure cases I hope you've enjoyed this 3:43 video and I'd love to see your 3:45 experiments please tag me on Twitter at 3:47 what's AI if you share them or join our 3:50 Discord Community where we created a 3:52 channel specifically for it I will see 3:54 you next week with another amazing AI 3:57 research 4:00 foreign 4:04 [Music]

ChatGPT Explained in 5 Minutes

ChatGPT explicado en 5 minutos

ChatGPT expliqué en 5 minutes

ChatGPT 5 मिनट में समझाया गया

ChatGPT を 5 分で説明

ChatGPT explicado em 5 minutos

ChatGPT được giải thích trong 5 phút

5 分钟解释 ChatGPT

Of all the tech companies that have been popular over the last decade, SaaS ( ) companies are arguably the most popular in the last few years. Software as a Service Now, you can see, all around, different kinds of SaaS companies for many different use cases. Some are as small as an auto-DM product, and others go all the way to enterprise level. With so much proliferation of SaaS, there are some misconceptions that have started to appear. In this article, we will explore how SaaS companies operate and clear misconceptions about their most important areas. How to Start Building SaaS Companies The most important part of this stage is to first identify a specific group of people (target audience) and understand what problems or pain points they have. You want to start by solving the problem with your existing knowledge and skills before you get into building any fancy software. The most common advice here is to start with yourself as a representation of your target audience. If you have found ways to solve your own problems, chances are other people like you still have them and would benefit from what you discovered. Once you have identified a specific problem and a solution for it on a small scale. It's time to find others like you to see if your solution works for them as well. Notice that, so far, we haven’t talked about any SaaS development, software, tech stack, or anything like that. And there’s a reason for it. You don’t need to know about code or have a development team to build a successful SaaS. Very counterintuitive, I know. You might be thinking, “It’s called software as a service and you’re saying that you don’t need to build software? Wut?“ Yes, but hear me out. You don’t need to reinvent the wheel first of all. You can use software that exists out there and test out your solution with more people. For example, if your SaaS idea is a system that lets people auto-schedule posts for social media, you can use a free version of existing services that work for one platform and aggregate several of them to get the end result for the user. The main point here is to make sure your solution is something that people want and are willing to pay for, even if it’s a bunch of different services that you pieced together. There’s nothing worse than coming up with a great software product, super polished, and with the latest technologies if it doesn’t solve a need and very few people, if any, want to pay for it. Once you have a proven solution for a problem that has people willing to pay for it, you can even build it using no-code tools and have users finance the costs of building and maintaining the product with their money. How do SaaS Companies make money? Now, the next important step after the building phase is getting paying users. SaaS companies can employ various monetization strategies to generate revenue. The most common approach is subscription-based pricing. This is where the users pay a monthly (or yearly) fee to access and use the SaaS platform. It is the most common strategy because it gives you a predictable income stream, you can look forward to having that amount every month (as long as the users don’t leave). But there are also other options available. For instance, you can provide different “service tiers” ranging from basic to enterprise. With this model, every tier has more features, more capacity, or more speed. And every tier has a different price with the initial one being the most affordable and the bigger one the most expensive. You can also have an enterprise-level tier which would have a particular price tailored to the company that makes use of the services. Depending on your SaaS, you can have a usage-based model or a token/credit model. In this case, there would not be a subscription but rather users would pay for their use of the platform within a period of time (e.g. monthly, quarterly, yearly) Another strategy is the use of “lifetime deals'' (LTD). It’s best to use this at the time of the launch of the platform or when a major update to the platform is released. Used properly, this strategy can net you a great amount of money from the start that you can use for improving the product, acquiring new users, or increasing marketing efforts. You can even use a combination of all the previous strategies, mixing and matching to find the proper combo that will be the most profitable for your SaaS. How are SaaS companies valued? Once you have a SaaS up and running with paying users, you want to look into how it is valued. Whether you’re aiming for a potential exit or a merger with another company in your current niche, knowing the value of your SaaS is important. Traditional valuation methods for tech companies don’t apply well to SaaS companies because there are many different factors that don’t apply. For instance, a SaaS company doesn’t usually have a headcount, it’s just the founder (or founders) working on it. There are no offices or tangible assets and no divisions or departments. And so, for SaaS companies, there are other metrics that are important for investors and potential buyers. For starters, the recurring revenue is measured in MRR or ARR (monthly or annually), and future revenue projections. However, even though it is important, it’s not only about revenue. There are 2 other metrics that are equally important (if not more). The first one is SDE (Seller’s Discretionary Earnings). These are all the expenses specific to the previous owner that can go back to the total profit amount. Say, for example, a SaaS company owner makes $120,000 a year in profit. This is after the owner took a cut of $30,000 to use as salary. In this case, a new owner needs to know that he/she has $150,000 in total profit to work with. The other metric to look at is EBITDA. A long acronym that means earnings before interest, taxes, depreciation, and amortization. When using this metric for valuation, instead of the owner’s salary, what’s added back into the total are the interest, taxes, depreciation, and amortization. This is done for the same reasons as the SDE calculation. Giving potential buyers and investors a more complete picture of how the SaaS company is doing financially. How to sell a SaaS company One of the logical next steps for many people after knowing how much the SaaS is valued is to think about selling it. Since SaaS is not a traditional tech company, other factors apply as well. We don’t need to talk about (IPOs), private equity, or reporting to stakeholders. initial public offerings Things that do happen, however, are mergers and acquisitions. This all depends on the size of the SaaS companies we are talking about. The situation of a SaaS that makes $2k MRR is much different than the one of a SaaS at the $20k MRR (and it’s not only about money). A great example of a merger in the SaaS world is one from a few years back with the fusion of ConversionAI built by Dave Rogenmoser and Headline built by Danny Postma. In a situation like this, the founders do their due diligence and negotiate the terms of the deal. Once they reach an agreement, the 2 SaaS companies join forces and become 1 for the public. The other case is an acquisition, where one person sells their SaaS to another person who from that point on becomes the operator and proprietor of the company. Acquisitions are much easier to carry forward nowadays than they were before. All that risk associated with selling your assets to a person that you don’t know and can potentially scam you of your hard work is now neutralized with intermediary platforms. In these platforms, there’s a “trusted third party” that ensures that both parties receive what they expect in a fair agreement. Examples of these third-party platforms are Acquire and Microns. They are also called “Startups Marketplaces”. The places where you go to buy or sell a startup. They work with different kinds and sizes of SaaS companies. Acquire now handles bigger and more reputed SaaS, while Microns focus more on the niche of so-called “micro-saas”. You can list your SaaS there, get offers within a few days, and fully sell it in a week or two. The process is much more streamlined in comparison to the DIY approach. You can also buy a SaaS that has a good base and some traction for which the original founder doesn’t have either the time, money, or expertise to grow further. And you can come along with your own resources to keep it going and turn a profit in the following months. You have the flexibility to either build a SaaS from scratch and then sell it for a higher price or buy an existing one and then grow it by multiples of its initial revenue. Plus, in many different countries, SaaS income is tax deductible so you can repeat this process more than once if you choose. Conclusion There you have it. Besides the technical aspect of how a SaaS can be built, there are other, arguably more important, aspects that will determine whether it has the chance to be a success or a total flop. It’s important to remember that SaaS companies are only as useful as the value they provide and the problems they solve for other people. Because without people with a need, there are no paying customers, and without those, there is no actual business. Creating and putting a SaaS out there in the market is not only for developers or indie hackers. They can also be a great bet for other types of profiles that are non-technical and have an entrepreneurial spirit. Having one (or more) of these SaaS companies is a great way to use the internet to create leverage. And what’s more?  You don’t have to trade time for money in a traditional job. I hope this has been useful and informative. Thanks for reading! Don’t forget to to not miss any of the coming articles. subscribe to me on HackerNoon

How Do SaaS Companies Work?

In the initial stages of community building, community managers invest significant time, effort, and resources in expanding channels to attract more users. However, even with sufficient traffic from these channels, the community may not become more active, and the number of users actively using the product within the community may not increase. This situation is akin to using a bamboo basket to fetch water: while the faucet may be turned on high, most of the water is still lost due to the basket's large gaps. To address this issue, community managers need to focus on reducing these gaps to retain as much water (i.e., users) as possible. Before seeking solutions, it's crucial to understand the root cause of the problem. Why are community users difficult to convert? The member count on platforms like Discord and Telegram is increasing daily, yet the number of users actively using the product remains unchanged. There's a disconnect between SNS and Web3 addresses. Most community member accounts are not linked to Web3 addresses, making it difficult for community managers to match active accounts within the community with active addresses on the blockchain. Community managers invest time, energy, and resources primarily in SNS activities such as increasing community size, daily activity, and accumulating chat records. However, the growth of active Web3 addresses, which are crucial for product usage, doesn't receive adequate attention or resources. Furthermore, there's a lack of long-term incentive mechanisms. Community management is a long-term endeavor, requiring a shift from focusing solely on community expansion to nurturing quality members who actively contribute value. Limited team resources and budgets result in most community activities being time-sensitive, posing challenges to converting community members into product users. Additionally, the lack of systemization and low automation levels exacerbate the issue. Many Web3 teams are still in their startup phase, facing resource and manpower constraints. Community management heavily relies on manual efforts, leaving little room to focus on converting community members into product users. How can these challenges be overcome? Perhaps we can find answers by looking at the market. Market Choice: Built-in Community & Long-term Incentives Built-in community Users are active in communities using their SNS accounts, while they engage with the ecosystem using Web3 addresses. Currently, most communities are centered around platforms like Discord and Telegram. Users join these communities using their Discord or Telegram accounts and then navigate to the official website through community links. However, they can't immediately experience the product; they still need to link their Web3 wallet address. Every additional step increases the likelihood of user dropout. Why not consolidate customer acquisition and retention efforts onto a single page? Some major projects have recognized this issue and chosen to build a built-in community on their official website. For instance, Arbitrum has a dedicated "Community" section on their website, allowing users to directly experience the product upon entering the community. In the operation of such built-in communities, community managers can directly engage with members using their Web3 addresses rather than SNS accounts. They can optimize the community interface and streamline processes to improve conversion rates. Building a built-in community on the official website requires a significant allocation of team resources, involving page design, development, and considerations about what tasks to include in the community to convert users into product users. For most Web3 teams, especially those in the early stages of startup, it's challenging to dedicate such extensive resources and time solely to community building. Teams need to balance various aspects of their operations and may not prioritize allocating such resources and time to community development. So, can community managers leverage external help to overcome the current challenges in community building? Are there mature solutions available in the market to assist project managers in quickly establishing a built-in community? Yes, several products have emerged in the market to address this need, and TaskOn is one of the platforms offering comprehensive functionality: Multiple task templates help project managers quickly establish the entire process from new users joining the community to experiencing the product. Custom Domain Management allows community managers to directly customize the domain of their community, seamlessly embedding the community within the official website, creating a community that is truly integrated with the project. Long-term Incentives: TGE + Points To further encourage community members to use the product, long-term incentives are essential. For projects that have not yet issued tokens, Token Generation Events (TGE) are a common approach. TGEs use the anticipation of airdrops to shape the community atmosphere, influence user behavior, and stimulate product usage. While TGE can prolong the community's patience with the project, there is also a risk of user dropout during the wait for the airdrop, which could occur at an unknown time. How can we reduce the dropout rate during this waiting period? Introducing a points-based rewards system could be a solution. By utilizing a points mechanism to establish a comprehensive user ranking system, rewarding every valid action, community users can receive timely feedback. Simultaneously, community managers can monitor the community's points holdings in real-time, aiding decision-making. Blast, for example, adopts a TGE + Points approach: Staking assets and inviting others can earn points, and the number of points held by an account is linked to the future airdrop value. There's even a dedicated leaderboard page to stimulate community members' enthusiasm. Coincidentally, Bitget recently employed a points strategy during the issuance of BWB tokens. Unlike Blast, however, they didn't opt to create a dedicated points page on their official website. Instead, they chose to transplant the project's points system to a third-party community solution platform. By leveraging the platform's native community management features, they were able to seamlessly integrate TGE + points, quickly and efficiently. For projects that have already issued tokens, implementing a points system can complement the project's design of a dual-token model. The dual-token model consists of equity tokens and utility tokens, with the already issued token serving as the equity token and the points acting as the utility token. Equity tokens relate to holder benefits, while points can be linked to community engagement and loyalty. By defining clear rules for points distribution and implementing an exchange mechanism to bridge points with utility tokens, loyal community participants can be incentivized, thereby injecting new vitality into the community and ecosystem. Maximizing Efficiency: Harnessing Tools for Success In a bull market, user attention is a scarce resource. Failing to retain users and encourage them to use the product immediately after joining the community results in extremely low conversion rates, making it less effective to spend more money on user acquisition. Focusing community operations on users' Web3 addresses rather than SNS accounts is essential for fundamentally improving community user conversion rates. Team resources and community managers' time and energy are limited. Utilizing tools can better assist teams in moving forward on the right path. In the initial stages of community building, community managers invest significant time, effort, and resources in expanding channels to attract more users. However, even with sufficient traffic from these channels, the community may not become more active, and the number of users actively using the product within the community may not increase. However, even with sufficient traffic from these channels, the community may not become more active, and the number of users actively using the product within the community may not increase. This situation is akin to using a bamboo basket to fetch water: while the faucet may be turned on high, most of the water is still lost due to the basket's large gaps. To address this issue, community managers need to focus on reducing these gaps to retain as much water (i.e., users) as possible. Before seeking solutions, it's crucial to understand the root cause of the problem. Why are community users difficult to convert? Why are community users difficult to convert? The member count on platforms like Discord and Telegram is increasing daily, yet the number of users actively using the product remains unchanged. There's a disconnect between SNS and Web3 addresses. Most community member accounts are not linked to Web3 addresses, making it difficult for community managers to match active accounts within the community with active addresses on the blockchain. There's a disconnect between SNS and Web3 addresses. Community managers invest time, energy, and resources primarily in SNS activities such as increasing community size, daily activity, and accumulating chat records. However, the growth of active Web3 addresses, which are crucial for product usage, doesn't receive adequate attention or resources. Furthermore, there's a lack of long-term incentive mechanisms . Community management is a long-term endeavor, requiring a shift from focusing solely on community expansion to nurturing quality members who actively contribute value. Limited team resources and budgets result in most community activities being time-sensitive, posing challenges to converting community members into product users. lack of long-term incentive mechanisms Additionally, the lack of systemization and low automation levels exacerbate the issue . Many Web3 teams are still in their startup phase, facing resource and manpower constraints. Community management heavily relies on manual efforts, leaving little room to focus on converting community members into product users. lack of systemization and low automation levels exacerbate the issue How can these challenges be overcome? Perhaps we can find answers by looking at the market. How can these challenges be overcome? Market Choice: Built-in Community & Long-term Incentives Built-in community Users are active in communities using their SNS accounts, while they engage with the ecosystem using Web3 addresses. Currently, most communities are centered around platforms like Discord and Telegram. Users join these communities using their Discord or Telegram accounts and then navigate to the official website through community links. However, they can't immediately experience the product; they still need to link their Web3 wallet address. Every additional step increases the likelihood of user dropout. Why not consolidate customer acquisition and retention efforts onto a single page? Every additional step increases the likelihood of user dropout. Why not consolidate customer acquisition and retention efforts onto a single page? Some major projects have recognized this issue and chosen to build a built-in community on their official website. For instance, Arbitrum has a dedicated "Community" section on their website, allowing users to directly experience the product upon entering the community. In the operation of such built-in communities, community managers can directly engage with members using their Web3 addresses rather than SNS accounts. They can optimize the community interface and streamline processes to improve conversion rates. Building a built-in community on the official website requires a significant allocation of team resources, involving page design, development, and considerations about what tasks to include in the community to convert users into product users. For most Web3 teams, especially those in the early stages of startup, it's challenging to dedicate such extensive resources and time solely to community building. Teams need to balance various aspects of their operations and may not prioritize allocating such resources and time to community development. So, can community managers leverage external help to overcome the current challenges in community building? Are there mature solutions available in the market to assist project managers in quickly establishing a built-in community? Are there mature solutions available in the market to assist project managers in quickly establishing a built-in community? Yes, several products have emerged in the market to address this need, and TaskOn is one of the platforms offering comprehensive functionality: TaskOn Multiple task templates help project managers quickly establish the entire process from new users joining the community to experiencing the product. Custom Domain Management allows community managers to directly customize the domain of their community, seamlessly embedding the community within the official website, creating a community that is truly integrated with the project. Long-term Incentives: TGE + Points To further encourage community members to use the product, long-term incentives are essential. For projects that have not yet issued tokens , Token Generation Events (TGE) are a common approach. TGEs use the anticipation of airdrops to shape the community atmosphere, influence user behavior, and stimulate product usage. While TGE can prolong the community's patience with the project, there is also a risk of user dropout during the wait for the airdrop, which could occur at an unknown time. How can we reduce the dropout rate during this waiting period? For projects that have not yet issued tokens Introducing a points-based rewards system could be a solution. By utilizing a points mechanism to establish a comprehensive user ranking system, rewarding every valid action, community users can receive timely feedback. Simultaneously, community managers can monitor the community's points holdings in real-time, aiding decision-making. Blast, for example, adopts a TGE + Points approach: Staking assets and inviting others can earn points, and the number of points held by an account is linked to the future airdrop value. There's even a dedicated leaderboard page to stimulate community members' enthusiasm. TGE + Points Coincidentally, Bitget recently employed a points strategy during the issuance of BWB tokens. Unlike Blast, however, they didn't opt to create a dedicated points page on their official website. Instead, they chose to transplant the project's points system to a third-party community solution platform. By leveraging the platform's native community management features, they were able to seamlessly integrate TGE + points, quickly and efficiently. For projects that have already issued tokens, implementing a points system can complement the project's design of a dual-token model . The dual-token model consists of equity tokens and utility tokens, with the already issued token serving as the equity token and the points acting as the utility token. Equity tokens relate to holder benefits, while points can be linked to community engagement and loyalty. By defining clear rules for points distribution and implementing an exchange mechanism to bridge points with utility tokens, loyal community participants can be incentivized, thereby injecting new vitality into the community and ecosystem. dual-token model Maximizing Efficiency: Harnessing Tools for Success In a bull market, user attention is a scarce resource. Failing to retain users and encourage them to use the product immediately after joining the community results in extremely low conversion rates, making it less effective to spend more money on user acquisition. Focusing community operations on users' Web3 addresses rather than SNS accounts is essential for fundamentally improving community user conversion rates. Team resources and community managers' time and energy are limited. Utilizing tools can better assist teams in moving forward on the right path. Utilizing tools can better assist teams in moving forward on the right path.

Guide to Web3 Community Management: How to Boost Community Conversion Rates

I recently got into a discussion on Twitter where I suggested that root-level directories don't make much sense when you're creating applications that are a library. It's conventional wisdom in the community, to suggest putting any code you do not want to expose to other applications inside the directory. And it's true if you're creating something that is meant to be important to other people’s code. The truth is, however, that most people are likely not working on other libraries but rather applications (APIs, web servers, etc). internal not Go internal Take this layout, for example: - app
    - cmd
	- app
	    - main.go
    - internal
    - services
    - repository
    .git
    go.mod
    go.sum A standard repository on github, gitlab etc. What does protect against here? Literally, any other package in this application will be on the same level as the directory, all will be able to import from it. The only situation, where this would not hold is if you were to take this entire code and copy it into another repository. And, honestly, when was the last time you did that? internal internal So, yes, it's technically correct (the best kind) that using root-level directories provides encapsulation (which is good). But, in practice, you don't really get any of the benefits of . If we were to add a view package to our application and wanted to start grouping different views in a sub-package, an directory suddenly starts to make sense. internal internal internal Let me illustrate: - app
    ...omitted
    - views
	layouts.go
	- home
	    home.go
	- about
	    about.go When does internal make sense? If we had some layout components (base, dashboard, etc) in the file that aren't exported, and wouldn't be able to import it as both are no longer part of the view package. If we export it, package in the application can import it, obviously not desirable. But, we can add an directory, export the layout components and encapsulate them from the rest of the application, like so: layouts.go home.go about.go any internal - app
    ...omitted
    - views
	- internal
	    - layouts
		base.go
		dashboard.go
	- home
	    home.go
	- about
	    about.go This is kind of a pet peeve of mine; it isn't really that important now that we have gotten modules (pre-modules was one of the reasons for internal which I will get into in a bit) and as long as you stay consistent about what goes into , it's all good. I prefer to use , as that to me at least better communicates what the directory is for. And I've seen quite a few Go applications in my time now, they either use or and most often contain the same kind of code. Auxiliary packages that are needed for the application as a whole but do not contain core business logic. Code to interact with , wrappers around a library to send mails, a etc. To me, for non-library code, this is the most important thing to get right, what do you expect to find in the directory not as much the same (again, you don't get any of the benefits from internal if you place it in the root)? internal pkg internal pkg aws queue Why do we have internal? To answer that question, we have to go back quite a bit. All the way back to the time before modules, when the creators of Go thought it a great idea to force everyone into their (Google's) preferred way of structuring code. You'd be forced into something like this: - $GOPATH
	- src
	- github.com
	    - user
		- repo
		    - cmd
		    - internal
		    - pkg Before Go 1.4, you could only have local and global components which could lead to frustrating situations where you'd like to have code that is only used within the module it’s defined and not part of the public repository. And in Go 1.4, the solution to this was introduced with the introduction of the directory. The Go compiler will verify that the package doing the import is within the same module as the package being imported. internal With the above structure, using as the default makes a ton of sense as it's quite easy to accidentally expose something that otherwise should've been kept private. But with the introduction of modules, this doesn't apply. Reading makes me think of something internal to a not the application as a whole. internal internal package Does all of this really matter? No. I tend to pick this "fight" just because I think it a bit funny how some people will go out of their way to argue that is the only correct way to do it. internal As argued above, if you're building something that is not meant to be imported into other people’s code, this is good advice. If you're building an application, consider using . But most importantly, be consistent. We spend too much time in software focusing on right and wrong as black and white, but it all depends. If the code that I'm arguing should go into a directory feels more natural for to be in an directory, then by all means, do that. pkg pkg you and your team internal Just be consistent. Also published here.

Debunking the Go Community's Conventional Wisdom on Internal Directories

Implicit operators in allow us to define custom type conversions that happen — you guessed it — implicitly when working with multiple types. Implicitly in this case means that we don’t have to explicitly cast the types since the implicit operators we implement handle this for us. C# Implicit operators in C# play a role in simplifying data type conversions. They enable you to convert one type to another seamlessly without explicitly casting the values. This feature can save you time and effort and improve the readability of code, but like all things we look at, there are cons to consider as well. Throughout this article, we’ll and examine code examples to illustrate their practical application. Let’s dive right in and learn all about implicit operators in C#! explore use cases for implicit operators in C# What are Implicit Operators in C#? Implicit operators in C# are a powerful feature that allows objects of one type to be automatically converted to another type without the need for an explicit cast. They provide a way to seamlessly convert between types, making code more concise and readable. Implicit operators are defined as special methods within a class or struct, using the keyword. These methods specify the conversion from one type to another. When the compiler encounters an assignment or expression involving compatible types, it will automatically invoke the appropriate implicit operator to perform the conversion. implicit Here’s an example to illustrate the concept: public struct Celsius
{
    public Celsius(double value)
    {
        Value = value;
    }

    public double Value { get; }

    // Define an implicit operator from Celsius to Fahrenheit
    public static implicit operator Fahrenheit(Celsius celsius)
    {
        double fahrenheit = celsius.Value * 9 / 5 + 32;
        return new Fahrenheit(fahrenheit);
    }
}

public struct Fahrenheit
{
    public Fahrenheit(double value)
    {
        Value = value;
    }

    public double Value { get; }
}

public class Program
{
    public static void Main()
    {
        // Implicitly convert a Celsius temperature to Fahrenheit
        Celsius celsius = new Celsius(25);
        Fahrenheit fahrenheit = celsius;

        Console.WriteLine(fahrenheit.Value);  // Output: 77
    }
} In this example, we have a type with a property. We define an implicit operator in the type that converts a value to . When we assign a value to a variable, the compiler automatically invokes the implicit operator, converting the temperature from Celsius to Fahrenheit. Celsius Value Celsius Celsius Fahrenheit Celsius Fahrenheit Implicit operators in C# can greatly simplify code by allowing objects to be converted implicitly when appropriate. This can make code more readable and reduce the need for explicit type conversions. However, it’s important to use implicit operators with caution and ensure that the conversion is safe and logical. Check out this video on using Implicit Operators in C# for more information: https://www.youtube.com/watch?v=tgPTQ-ST8qQ&embedable=true Pros and Cons of Implicit Operators in C# Like everything we look at, there are going to be pros and cons. I try to make sure that every topic we cover together on both my site and looks at multiple perspectives. In my opinion, this is the best way to understand when things are a better or worse fit. my YouTube channel Pros of Implicit Operators in C# Implicit operators in C# provide several benefits in software development. They can simplify code and improve readability by allowing automatic type conversions without requiring explicit casting or conversion methods. This eliminates the need for repetitive and potentially error-prone code, making the codebase more concise and easier to understand. Consider the following example where we have a custom type, , representing a unit of measurement that we’re working with: Length public struct Length
{
    public double Value { get; set; }

    // Implicit conversion from Length to double
    public static implicit operator double(Length length)
    {
        return length.Value;
    }
} With the implicit operators defined, we can use this custom type in calculations without explicitly converting them to their underlying types: Length length = new Length { Value = 5.0 };
double finalResult = (length * 1.23) / 42d;
Console.WriteLine($"The answer is {finalResult}."); An important note here is that probably any quantity that has a value like this would need to indicate the unit of measurement — this is omitted in this example just because you could do this in a number of ways and I don’t want that to be the focus. So there’s an assumption in this example that we DO know what unit we’re working with here. The implicit conversion thanks to the operator that we added simplifies the code by reducing the number of explicit conversions and improves readability by expressing the intent more clearly. If we had to litter mathematical statements with (double) and other casts throughout it, it starts to detract from the understanding of the expression itself. Cons of Implicit Operators in C# One of the big cons of implicit operators is very much related to one of the pros that we looked at. The fact that we CAN implicitly convert can lend itself to very odd situations if we’re not careful about what we implicitly convert to. Let’s introduce another custom type that can also be cast to a double. We can make a similar assumption as before that we know the units of this quantity-representing type. Here’s the code, very much like the previous type: public struct Temperature
{
    public double Value { get; set; }

    // Implicit conversion from Temperature to double
    public static implicit operator double(Temperature temperature)
    {
        return temperature.Value;
    }
} Because both we have the power to write mathematical expressions like this without casting — but should we? types are convertible to double implicitly, Length length = new Length { Value = 5.0 };
Temperature temperature = new Temperature { Value = 25.0 };
double finalResult = ((length * temperature) + 42d) / 1.23;
Console.WriteLine($"The answer is {finalResult}."); In this example, the implicit operators allow the multiplication between and objects to be performed directly, without the need for explicit conversions. In isolation, it may have made more sense to allow for either type to be convertible to double, but when they both can be, the results may be unexpected. Length Temperature To elaborate, with an example where in isolation if your length was meters, casting them to a double called length in meters isn’t too much of a stretch. But double itself is unitless, and when we start compounding this by mixing in other types, the burden of tracking what unit we’re *actually* talking about starts outweighing the benefit of the implicit conversion. In my opinion, it would be much more readable if we were forced to explicitly cast and track the conversions in intermediate steps if necessary. This is of course one example, but the point is that if you are doing implicit conversions where you potentially lose data resolution (in this case, units), then you’re at risk of this sort of thing. Nothing prevents us as C# developers from doing this — except maybe other developers on pull requests and code reviews! Use Cases for Implicit Operators In this section, I’ll present three practical use cases for implicit operators in C#. Implicit operators are a powerful feature that allow for automatic conversion between different types. Understanding and utilizing implicit operators can greatly simplify your code and improve its readability. Let’s explore three use cases where implicit operators can be useful in C#. Converting Custom Types – Money on My Mind One of the primary use cases for implicit operators is converting custom types. Suppose we have a custom type , which represents a some amount of currency. We may want to allow implicit conversion from to to simplify calculations and enable direct comparisons. Here’s how we can define an implicit operator to achieve this: Money Money double public struct Money
{
    private readonly double _amount;

    public Money(double amount)
    {
        _amount = amount;
    }

    public double Amount => _amount;

    // Implicitly converts Money to double
    public static implicit operator double(Money money)
    {
        return money._amount;
    }

    // Implicitly converts double to Money
    public static implicit operator Money(double amount)
    {
        return new Money(amount);
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        Money moneyInWallet = new Money(100.50); // $100.50
        double cash = moneyInWallet; // Implicit conversion to double
        
        // Adding more money
        moneyInWallet += 99.50; // Implicit conversion from double to Money, then addition

        Console.WriteLine(cash); // Output: 100.5
        Console.WriteLine(moneyInWallet.Amount); // Output: 200
    }
} By defining an implicit conversion operator from to , we can now directly assign a object to a variable without the need for explicit type casting. If you wanted to have financial calculations that were more expressive by having a type, this could be useful without forcing casting operations everywhere. Money double Money double Money Simplifying Math Operations Implicit operators can also simplify math operations by automatically converting operands to compatible types. Let’s say we have a type representing complex numbers, and we want to perform arithmetic operations on them. By using implicit operators, we can seamlessly convert integers and doubles to when performing mathematical operations. In this case, we’ll not only need implicit operators for converting, but we’ll need an operator for doing arithmetic between two instances. ComplexNumber ComplexNumber ComplexNumber Here’s an example: public class ComplexNumber
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

    public ComplexNumber(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // Implicitly converts int to ComplexNumber
    public static implicit operator ComplexNumber(int number)
    {
        return new ComplexNumber(number, 0);
    }

    // Implicitly converts double to ComplexNumber
    public static implicit operator ComplexNumber(double number)
    {
        return new ComplexNumber(number, 0);
    }

    // Adds two ComplexNumber instances
    public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b)
    {
        return new ComplexNumber(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }
}

// Usage
ComplexNumber complexNumber = 2.5; // Implicit conversion from double
complexNumber += 3; // Implicit conversion from int
Console.WriteLine(complexNumber.Real); // Output: 5.5 With implicit operators, we can perform mathematical operations on objects using integers or doubles without explicit conversions. If you were creating an application where there was a lot of arithmetic with these concepts, you may find that it improves the readability of your code to not have to routinely cast. ComplexNumber Conversions with Other Libraries: A Geometry Example Implicit operators can be particularly useful when working with libraries or APIs that have different types representing similar concepts. By creating implicit operators between these types, you can seamlessly convert between them and simplify interactions with the library. For example, consider a library we’d like to create that provides different types for representing points in 2D space. The library may define and types, each with its own set of operations. By defining implicit operators between these types, you make it easier for users to work with these objects interchangeably, depending on the context: Point2D Vector2D public struct Point2D
{
    // Implicit conversion from Point2D to Vector2D
    public static implicit operator Vector2D(Point2D point)
    {
        return new Vector2D(point.X, point.Y);
    }
}

public struct Vector2D
{
    // Implicit conversion from Vector2D to Point2D
    public static implicit operator Point2D(Vector2D vector)
    {
        return new Point2D(vector.X, vector.Y);
    }
} With these implicit operators in place, users can seamlessly convert between and objects, depending on the needs of their code: Point2D Vector2D Point2D point = new Point2D(2, 3);
Vector2D vector = new Vector2D(4, 5);

// Implicit conversion from Point2D to Vector2D
Vector2D convertedVector = point;

// Implicit conversion from Vector2D to Point2D
Point2D convertedPoint = vector; In this scenario, implicit operators simplify the code and make it more expressive by allowing users to work with the same underlying data with different objects representing different concepts. There may be benefits in similar situations where we’re incorporating a third-party library into our code base, and want to offer a level of flexibility when interacting with it. For the types that we own, we could provide implicit conversions to the library in question, and it may simplify logic within our codebase when interacting with the library. Wrapping Up Implicit Operators in C# In this article, we explored implicit operators in C#, and how they can simplify code and improve code readability. Implicit operators allow for automatic conversions between different types, making it easier to work with data and objects in C#. My personal opinion on implicit operators in C# is that type conversion is easy to “get wrong”. If you’re not sure what you’re doing, I think it’s an easy thing that you could mess up and create more complications in your code than it’s worth getting potential readability out of it. However, if you’re creating code that has an emphasis on working between several types as the core of what you’re doing, you may have better insights into effective ways to use these properly. If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published here.

How To Simplify Type Conversions with Implicit Operators in C#

The Conventional Commits specification is a lightweight convention that provides a standardized format for writing commit messages. It defines a simple set of rules to structure commit messages in a consistent manner, making it easier to understand the purpose and context of each commit. It is based on the above anatomies of git. By addressing numerous “why”, “what” and “how” questions, this specification can enable an efficient understanding of past decisions and changes made in the codebase, even after months or years. They serve as an indirect wiki, offering valuable insights into the reasons behind code changes. According to this specification, a commit message should be structured as: <commit type>[optional scope]: <description>
[optional body]
[optional footer(s)] Categorization of Commit Types 1. Build This type is used for changes that affect the build system or external dependencies. For example, if you upgrade a library or modify build configurations, it falls under this category. build: update webpack configuration
build: update Hive Maven dependency to version 3 2. Chore Chore-type commits are for regular maintenance tasks, such as updating dependencies, package manager configurations, or other tasks that don’t modify the source code or affect the behavior of the application. chore: clean up unused dependencies from package.json 3. CI Commits related to continuous integration configurations or scripts. This includes changes to tools and processes used for automation and testing. ci: add vault stage to gitlab ci pipeline to fetch api secrets 4. Docs Commits that only involve documentation changes, such as updating README files, adding comments, or writing documentation for functions or classes. docs: add auth service instructions to README 5. Feat This type is for new features added to the project. If you introduce new functionality or capabilities, it’s considered a feature. feat: introduce real-time notifications for new messages 6. Fix Fix-type commits are for patches that resolve bugs or issues in the codebase. If the commit addresses a problem or bug, it falls under this category. fix: resolve issue with form submission not triggering validation 7. Performance Commits that improve the performance of the codebase without changing its external behavior. Optimization-related changes would be categorized as performance improvements. perf: optimize guest misconduct database search by reservation for faster retrieval 8. Refactor Refactoring commits involve modifications to the code that neither fix a bug nor add a feature. Refactoring aims to improve the code’s structure, readability, or maintainability without changing its external behavior. refactor: simplify validation logic in user registration 9. Revert Revert-type commits are used when reverting previous changes. It’s essential to mention the commit ID or title of the changes being reverted in the commit message. revert: revert changes made in commit abc123 10. Style Commits that are related to code style and formatting. This could include indentation changes, code reformatting, or renaming variables to follow coding conventions. style: format code according to linting rules 11. Test Commits that add or modify tests. This includes unit tests, integration tests, or any other kind of automated testing. test: add unit tests for authentication service 12. Breaking Change This is not a commit type but a section in the description as per conventional commit specification. This introduces changes that are not backward compatible with the existing codebase or API. In other words, it signifies modifications that could potentially break existing functionality or require adjustments in dependent code or configurations. feat: update API response format to include additional fields

This commit extends the API response format to include new fields for user profile information. 
The added fields include 'birthdate' and 'country', providing more comprehensive user data. This 
change enhances the functionality of the API and enables richer user experiences.

BREAKING CHANGE:
- The structure of the API response has been modified to include additional fields.
- Clients relying on the previous response format will need to be updated to accommodate the changes.
Another syntax for breaking change — https://www.conventionalcommits.org/en/v1.0.0/#commit-message-with--to-draw-attention-to-breaking-change Usage in Open Source One of the many open-source examples using conventional commit specification is angular. Link — angular/CONTRIBUTING.md <type>(<scope>): <short summary>
│ │ │
│ │ └─⫸ Summary in present tense. Not capitalized. No period at the end.
│ │
│ └─⫸ Commit Scope: animations|bazel|benchpress|common|compiler|compiler-cli|core|
│ elements|forms|http|language-service|localize|platform-browser|
│ platform-browser-dynamic|platform-server|router|service-worker|
│ upgrade|zone.js|packaging|changelog|docs-infra|migrations|
│ devtools
│
└─⫸ Commit Type: build|ci|docs|feat|fix|perf|refactor|test What Are the Advantages? : Helps maintain consistency and standardization across commits within the team. When everyone follows the same format, it becomes easier to understand the history of changes. Consistency : By categorizing commits into types like feat, fix, docs, chore, etc., conventional commit messages provide semantic meaning to changes. This makes it easier to understand the nature of each commit at a glance. Semantic Meaning : Encourages writing clear and descriptive commit messages, including information about the changes made, why they were made, and any associated issues or task identifiers. Clarity : Facilitates communication among team members by providing a structured way to convey information about code changes. Communication : Enables the use of automated tools that can parse commit messages to generate release notes, changelogs, or perform other tasks based on commit history. Automation What Are the Disadvantages? : Without guidelines, commit messages may vary widely in format and quality, making it harder to understand the history of changes. Inconsistency : Lack of structure can lead to vague or incomplete commit messages, which may make it difficult for team members to understand the context or purpose of certain changes. Ambiguity : Tracking changes becomes more challenging, especially when trying to understand why certain changes were made or when investigating issues. Difficulty in Tracking : Poorly written commit messages can result in miscommunication or misunderstandings among team members. Miscommunication : Tasks such as generating release notes or tracking changes may require more manual effort without structured commit messages. Manual Processes FAQ About Conventional Commit Recommended to go over this list — Conventional Commits Resources Conventional Commits Specification Commitzen tool for the teams practices This blog was originally published on https://www.pranaybathini.com/2024/03/conventional-commit-specification.html

Conventional Commit Specification Guidelines: What You Need to Know

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

Let's learn about via these 60 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Conversational Ai /Learn Repo The automated chatbot that most websites nowadays have as customer service; does basic answer and response tasks. 1. The Social Impact That Deepfake Porn Has On Its Victims Recently, Deeptrance revealed that 15,000 deepfake videos were uploaded daily. 96% were clear pornography of morphed celeb faces onto adult entertainers. 2. Take ChatGPT With You: Introducing Ariana, the ChatGPT Assistant That Lives in WhatsApp Meet Ariana, a ChatGPT AI assistant living in WhatsApp, providing instant answers, translations, and idea generation. 3. Welcome to the World of Artificial Intelligence Programming Discover everything you need to know about artificial intelligence programming 4. Artificial Intelligence That Doesn’t Annoy Customers How to make virtual assistant (conversational AI chatbot), that doesn't get users angry 5. Interview with CEO & Co-founder of Symbl.AI Surbhi Rathore is the cofounder of Symbl, a programmable platform enabling developers to build next-generation AI-powered communication experiences 6. How to Build a Conversational AI bot Using Blenderbot How to build a conversational Bot with the Blenderbot model, an Open Source Language Generation Model made by Facebook AI so that you can have your own Siri. 7. Why is the Education Industry Opting for Conversational AI? As we all know that education is very much important in ones life. Conversational AI can help to improve the  teacher and student interaction. 8. How the Conversational AI Analytics will transform the business? 9. An Essential Guide to Data Collection for Conversational AI With conversational AI being the future of interactions, how can businesses develop and launch rock-solid solutions? 10. As AI Gets More Emotionally Intelligent, So Must We How people behave in solitude is vastly different than how they behave in public, but the foundation of one’s persona remains constant. Dancing around the apartment when nobody’s watching expresses a secret desire to do so on a grand stage, but humans modulate those whims as societal norms dictate. 11. Using ChatGPT to Recover Amounts Owed by Your Client Read how a CEO used ChatGPT to generate a scary email to get $109,500 owed to his company. 12. Is AI Really Disrupting the Way We Live and Work? As artificial intelligence becomes more and more integrated into our workplace and daily life, it will fundamentally disrupt the way we live and work. A recent survey of 5,700 Harvard Business School alumni found that even in the elite group, 52% believe that the number of employees in general companies will decrease in the three years from now. 13. ChatGPT is a Huge Win for Conversational AI Companies (and Their Customers) — Here's Why Find out why we believe ChatGPT is a massive win for conversational AI companies and how this incredible language model can be harnessed to enhance NLU. 14. Improving AI-Assisted Conversation With Zero-Shot Learning Assimilating zero-shot learning with machine learning networks holds many advantages for developers across a wide range of fields. 15. [Infographic] The State of Conversational AI in 2020 Conversational AI was always poised to take off in 2020. In fact, Gartner predicted that 80% of businesses would implement some sort of conversational interface by the end of this year. With the emergence of COVID-19 came compounded growth for the category - and I wanted to capture just how far we’ve come. So for the conversationally curious out there, I created this infographic that offers a clear depiction of where conversational AI stands at this very moment in time. [16. MAKE CONVERSATIONAL AI WORK at JUNCTION 2020 HACKATHON](https://hackernoon.com/make-conversational-ai-work-at-junction-2020-hackathon-pts3egp) 17. The Power of AI in Recruiting: How The Business World is Changing for Good AI drastically improved the world around us in many different ways. However, there are still many notable concerns with regard to overall impact on employment. 18. The Conversational AI Arms Race Has Begun The grown-ups have entered the room. Google and Microsoft have officially entered the conversational AI arms race in search. 19. Voice is the Safest and Most Accurate for Emotion AI Analysis Voice is one of several unique, innate, and immutable biometric identifiers. Other identifiers include retinal scans, iris scans and facial geometry scans. As technology evolves, so does the public’s concern regarding issues of privacy. Consider, for example, the turmoil DNA evidence introduced to our legal system in the late 1990’s, or, the controversial introduction of fingerprint evidence in the 1910 murder trial of Clarence Hiller in Chicago, Illinois. 20. How To Build an AI-Powered Financial Assistant App Find answers to the most common questions related to the development of a financial management application in 2022. 21. Conversational AI in Healthcare: 2 Key Use Cases If there is a silver lining somewhere with the COVID-19 pandemic engulfing the globe, it’s that we have been forced to introspect on the healthcare sector, both public and private, and whether it has the tools it needs – not only to deal with such crises, but to ensure the best possible healthcare outcomes even under normal circumstances. 22. 7 AI-powered Chatbots If you’re a millennial, you’ll know SmarterChild, the first-ever instant messaging bot with natural language comprehension ability. It was developed in 2000 and demonstrated exceptional wit, which most of today’s bot cannot. SmarterChild used to chat with about 2,50,000 humans every day with funny, sad, and sarcastic emotions. Today, we’ve traveled a distance with technologies like AI, ML, NLP, etc. and bots like Xiaocle have passed Turing tests of 10 minutes (i.e. users couldn’t identify that they’re talking to a bot for about 10 minutes). 23. Discussing The Applications of AI Chatbots in Healthcare at the World Economic Forum The World Economic Forum is mostly known for its highly anticipated annual meeting in Davos, Switzerland — a scene of global intrigue and a convergence point for the planet’s most influential politicians, investors, activists, CEOs, and economists. 24. ChatGPT for Office Politics: When is it Ethical? Have you ever stopped to consider the power of language models like ChatGPT and how they can impact our beliefs and opinions? 25. Drive Success with Conversational Marketing: The Feedback-Oriented Approach Conversational marketing can be a solution to achieve faster response times. In this guide, we discuss how to develop effective chatbot applications. 26. What Patients Are Asking Our COVID-19 Virtual Assistant According to a recent Pew Research Center poll, in just one week (March 16–24), the number of Americans who view the coronavirus as a major threat to public health spiked by nearly 20%, from 47% to 66% — a figure that is growing exponentially. 27. An Intro to MedPaLM: ChatGPT's Healthcare-Focused "Cousin" ChatGPT for healthcare? Learn everything you need to know about MedPaLM, a new LLM developed by Google specifically for medical and clinical applications. 28. 7 Ways Banks Can Use Conversational AI to Stay Relevant In Today's FinTech Era Learn how banks can leverage conversational AI and stay relevant in the age of FinTech including the rise of contactless payment methods, omnichannel, and more. 29. How We Built a Voice-Activated Lovecraftian Adventure Game In this article, we will discuss why we decided to create a voice-controlled game, what was the hardest part, and why we decided to open up about the money we make in the emerging market of conversational AI. 30. [Reviewed] 6 Conversational Feedback Tools Chatbots for surveys, surveybots, conversational surveys, feedback chatbots, conversational survey tools, AI survey tools, chatbot questionnaires. The list of names goes on and on. But how do they compare and which one is the best performer? 31. The Quest for Better Music Recommendations Through ChatGPT Prompt Engineering Prompt Engineering leads to an Open Source Obsidian Plugin to help researchers, an imagination-powered music recommendation engine, and some solid playlists. 32. Building A Chatbot On Your Own Might Not Make As Much Sense As You Think Over the past decade plus, chatbots have dominated the conversation (no pun intended) when it comes to digital engagement. You’ve undoubtedly had experiences interacting with them, some helpful while others underwhelming, and perhaps even fiddled around with building one on your own. 33. Amazon QuickSight Q Review Vs. NLSQL: A Comparison New Amazon QuickSight Q AI-powered product for Data Analytics Review and comparison with NLSQL competitors NLP to SQL API software (including pricing details) 34. How to Build Basic Chatbot Without Coding and Deploy to Websites Build best automated AI chat bot using Google Dialog flow 35. 7 Effective Ways to Improve Your Content Marketing with AI Tools Artificial Intelligence (AI) has numerous business use cases and can be applied to customer service, sales, lead generation, and marketing. 36. Understanding Conversational AI: As Chat Enabled Customer Service Technological innovations are necessary to cope up with the customer demands. Customers nowadays use multiple channels to access the services from a business. Thus, they expect multiple channel customer service from companies. 37. Math GPT: Can AI Help Solve Unified Theory ? What if we trained AI to complete equations instead of images of Cats? 38. "AI Can’t 'Think” Like Us Independently," - says Machine Learning Engineer Mani Sarkar In our new blog series, we’re interviewing data scientists and machine learning engineers about their career paths, areas of interest and thoughts on the future of AI. We kick off this week with a 20-year veteran and jack-of-all-trades when it comes to machine learning and data science: Mani Sarkar. Mani is a strategic machine learning engineer based in London, UK, who believes in getting beyond the theoretical and applying AI to real-world problems. [39. Generative AI is Coming for Publishing, But It's Not as Clear-Cut as It Looks](https://hackernoon.com/generative-ai-is-coming-for-publishing-but-its-not-as-clear-cut-as-it-looks) A look at the future of generative AI. 40. Can Artificial Intelligence Claim To Be the Future of Account-Based Marketing? To be honest, I hate phrases like “harness the power of AI” or “use AI to revolutionize your sales”. 41. How to Improve Privacy in Conversational AI Artificial intelligence is a great tool that assists you with fostering your business on the internet. 42. Introducing Conversation.ai This post has been authored by Aakrit Vaish, Co-Founder & CEO of Haptik 43. ChatGPT Writes a Story With Me I started with a story prompt to ChatGPT and then we kept going, I like it. 44. Where are the Chatbots and What is the Progress and Limitation of Virtual Assistants [2020 Edition] Cat's out of the bag: it may have been a long while since you’ve last conversed with a human customer service agent. More and more companies have turned to digital assistants to address the needs of customer inquiries. With messaging being the preferred method of communication, chatbots have taken over online facing services, due to their simplicity, affordability, and accuracy. 45. Data and Analytics Predictions for 2020 [A Top 5 List] It would be no exaggeration to say that the capacity of technology to advance itself is proceeding at a faster rate than our ability to process these changes all at the same time. This is both amazing and alarming in the same breath. 46. Conversational AI is Changing the Way We Interact With Data Large language models like ChatGPT are making it easier to manage data. Akkio has come up with an LLM-based tool to manage tabular data using conversational AI. 47. AWS Chatbot Magic: Building Conversational AI with AWS Services AWS offers a range of services that can be used for chatbot development and deployment. The steps outlined in this article show you how. 48. Why Chatbots Are The Future Of Customer Retention? Customer retention has become a genuinely challenging task for entrepreneurs. In the midst of all this, AI-assisted Chatbots are the real game changers. 49. Can Conversational AI Become The Face of Tomorrow's Business? In recent times, conversational AI has become a tech buzzword in the global market. However, the aggressively growing popularity of AI is leaving many individuals in a great dilemma of whether they should be fear of losing jobs in the future or get excited to leverage the latest edition of the AI-driven applications in businesses. 50. How to Streamline the Landlord-Tenant Relationship Through Conversational AI According to Mashivor, 50% of tenants move out because they are not happy with their landlord. The landlord-tenant relationship is more often than not a contentious one. It features two sides with similar intentions but entirely different priorities. Both parties are interested in peaceful, fluid, and uneventful correspondence and both are wary of being cheated, ill-treated, and misinformed. 51. Conversational AI for President: The Covid-19 Chatbot Use Case Our interactions with government agencies hardly ever find their way into our dinner-table conversations, yet they play a huge role in our everyday lives. 52. LSTM Based Word Detectors This article aims to provide the basics of LSTMs (Long Short Term Memory) and implements a word detector using the architecture. 53. Why Are We Training AI like Dogs Instead of Humans? The fundamental problem of the modern AI is that it tries to create a sophisticated trained dog. This approach is a dead end and needs to be drastically changed 54. Building a Conversational AI Chatbot With AWS Lambda Function and Amazon EFS Amazon announced the general availability of AWS Lambda support for Amazon Elastic File System. Amazon EFS is a fully managed, elastic, shared file system and designed to be consumed by other AWS services. 55. How Conversational AI Tool Can Help You Attract Real Estate Buyers And Residents Step One: Prospecting 56. A Comparison of GPT-3 and Existing Conversational AI Solutions Earlier this year, Elon Musk-backed artificial intelligence laboratory, OpenAI, released its latest, much anticipated autoregressive language model, the Generative Pre-trained Transformer 3 (GPT-3). Emerging to much fanfare and slated as the usherer of a new age of artificial intelligence, the number of articles, blog posts, and news pieces about this language model, perhaps match only the number of parameters the GPT-3 learned; 175 billion (Ok, this may be an exaggeration, but you get my point). 57. The Robots are Coming! - An Interview with Ilan Kasan, CEO at Exceed AI This article talks about automation and artificial intelligence and how it is impacting the sales industry and how the future will look in the age of AI. 58. What We Can Learn From Great Examples of Conversational User Interface Top-notch CUI’s offer a more human-like conversation. This helps in bridging the gap between physical and online conversations, and these brands do it right. 59. New Weapon in the Fight Against COVID-19: Digital Health Passports *Note: This article first appeared in the Los Angeles Tribune by Hyro's Head of Marketing Aaron Bours 60. What Is Conversational AI: Principles and Examples In this article, we will take the time to explain what conversational AI is: principles and examples to have a better idea of ​​how you can implement it. Thank you for checking out the 60 most read stories about Conversational Ai on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

CONVERSIONAL

conversion.al

-- employees

Since n.d.

COMPANY RANKING

CONVERSIONAL

EVERGREEN INDEX #2781

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

Conversional WIKI

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

CONVERSIONAL

conversion.al

-- employees

Since n.d.

COMPANY RANKING

CONVERSIONAL

EVERGREEN INDEX #2781

RELATED COMPANIESRANK

STORIES ABOUT CONVERSIONAL

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

Conversional WIKI

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