You woke up this morning with an idea for a language AI app. This app would generate innovative startup ideas just by a user entering the nature of the industry, such as productivity, education, food, and so on. It could help aspiring founders brainstorm the next big thing they are going to build. You experimented with the Cohere API, and it worked!
Now you can’t wait to test it out and get much-needed feedback by sharing it with the world. And then you realize you’re stuck.
Web development is a multi-stage process, and the front-end development will usually come back in towards the end of the process. And while it may seem like front-end development should be one of the quickest parts of the process, it often turns out to be quite a lengthy endeavor.
Enter Streamlit. It provides a very fast way to build front-end web applications with very little hassle. In this article, we’ll see how we can quickly prototype our Startup Idea Generator idea, deploy it as a web app and share it with the world!
To give you an idea, here’s a preview of what the final app looks like.
But let’s go back to the start and see how we might approach this. We can break the plan into three key steps, as follows:
- Build the language AI back-end with Cohere
- Build the front-end with Streamlit
- Deploy with Streamlit Cloud
We’ll see only selected code snippets in this article, but you can find the complete code in this repository.
1 - Build the language AI back-end with Cohere
Build the startup idea generator
The first thing we need to do is to build our main feature - the startup idea generator. For this, we use Cohere’s Generate endpoint, which generates text given an input, called a prompt.
Creating prompts, or prompt engineering, does require some experimentation. This is also good news - it means there’s huge room for you to innovate and apply your own creativity in designing prompts that get the best out of the endpoint. Read this documentation if you are interested in learning more.
In our case, we create a prompt containing a few examples of an industry and its corresponding startup idea. And since we want our app to take a user input (i.e. the industry) before generating an idea, our prompt ends with the term “Industry:”.
The following is what the prompt looks like.
This program generates a startup idea given the industry. Industry: Workplace Startup Idea: A platform that generates slide deck contents automatically based on a given outline -- Industry: Home Decor Startup Idea: An app that calculates the best position of your indoor plants for your apartment -- Industry: Healthcare Startup Idea: A hearing aid for the elderly that automatically adjusts its levels and with a battery lasting a whole week -- Industry: Education Startup Idea: An online primary school that lets students mix and match their own curriculum based on their interests and goals -- Industry:
We then build a function that leverages Cohere’s Python SDK to take in a user input and return the generated text, and the code looks as follows.
def generate_idea(industry): base_idea_prompt="< OUR FULL PROMPT STRING >" response = co.generate( model='xlarge', prompt = base_idea_prompt + " " + industry + "\nStartup Idea: ", max_tokens=50, temperature=0.5, k=0, p=0.7, frequency_penalty=0.1, presence_penalty=0, stop_sequences=["--"]) response = response.generations.text response = response.replace("\n\n--","").replace("\n--","").strip() return response
Notice that now the prompt is a concatenation of the base prompt that we created earlier, the industry name provided by the user, and the “Startup Idea:” prefix. This ‘forces’ the model to generate an output in a similar pattern to our prompt, that is, the startup idea description.
We also passed a number of arguments to the Generate endpoint, such as
stop_sequences, and so on. If you’d like to know what they mean, you can find their definitions in the Generate API reference.
Doing a quick test, entering “Public Transportation” returns the following startup idea: “A small electronic device that notifies users when they have to get off the train or bus”. Looking good so far.
Build the startup name generator
Being able to generate startup ideas is great, but it would make the app much more exciting if we could also suggest a startup name for each of the ideas. For this, using a similar approach as before, we create a new prompt containing a few examples of a startup idea description and its corresponding startup name. The following is what the prompt looks like.
This program generates a startup name and name given the startup idea. Startup Idea: A platform that generates slide deck contents automatically based on a given outline Startup Name: Deckerize -- Startup Idea: An app that calculates the best position of your indoor plants for your apartment Startup Name: Planteasy -- Startup Idea: A hearing aid for the elderly that automatically adjusts its levels and with a battery lasting a whole week Startup Name: Hearspan -- Startup Idea: An online primary school that lets students mix and match their own curriculum based on their interests and goals Startup Name: Prime Age -- Startup Idea:
We create another function that takes in a startup idea as the input and returns the generated startup name. The code looks as follows.
def generate_name(idea): base_name_prompt="< OUR FULL PROMPT STRING >" response = co.generate( model='xlarge', prompt = base_name_prompt + " " + idea + "\nStartup Name:", max_tokens=10, temperature=0.5, k=0, p=0.7, frequency_penalty=0, presence_penalty=0, stop_sequences=["--"]) response = response.generations.text response = response.replace("\n\n--","").replace("\n--","").strip() return response
Doing a quick test, entering the public transportation startup idea we got earlier returns the following startup name - “Beepro”. Not bad.
2 - Build the front-end with Streamlit
Build the basic components
Now that we’ve got the text generation part working, let’s create the front-end with Streamlit. Streamlit is an open-source Python library that makes it easy to create and share custom web apps. Instead of hours or even days, you can get a basic front-end up and running and deploy it in a matter of minutes.
The following is our front-end code using Streamlit, that in just a few lines, gets us a basic working app.
st.title("🚀 Startup Idea Generator") form = st.form(key="user_settings") with form: industry_input = st.text_input("Industry", key = "industry_input") generate_button = form.form_submit_button("Generate Idea") if generate_button: startup_idea = generate_idea(industry_input) startup_name = generate_name(startup_idea) st.markdown("##### " + startup_name) st.write(startup_idea)
It uses a number of features from the Streamlit API, as follows:
- A form via the
st.title()for the header title
st.text_input()for the user text input
- A submit button that comes with
st.write()to display the generated text.
We can deploy this Streamlit app by running the following command at the terminal (in this example, our code above is stored in
$ streamlit run app.py
Running the app locally renders the following.
Add some interactivity
Now that we have a basic version of the app running, let’s see how we can enhance it. One way is giving greater control to users when generating the ideas. Let’s add a couple of options to add interactivity to the app.
The first one is straightforward. We want to let users generate more than one idea in one go. For this, we’ll use the
st.slider() widget to let users input the number of generations to make. We’ll set the maximum number of generations to 10.
The second is a bit more interesting. With the Generate endpoint, we can use the
temperature parameter to control the randomness of the model output. The value can range between 0 and 5. Lower values tend to generate more “predictable” output, while higher values tend to generate more “creative” output. The sweet spot is typically between 0 and 1, and for our app, we’ll just add a small buffer and set the range to be between 0.1 and 0.9. We’ll name this user setting
For this, we’ll also use
st.slider() to let the users control the
temperature value. We’ll also need to modify the
generate_name() functions to accept the
temperature argument, to be passed to the Generate API call. The following is the example with
def generate_idea(industry, temperature): base_idea_prompt="< OUR FULL PROMPT STRING >" response = co.generate( model='xlarge', prompt = base_idea_prompt + " " + industry + "\nStartup Idea: ", max_tokens=50, temperature=temperature, . . . . . .
Let’s also add a couple more things. First, we’ll use
st.progress() to show a progress bar as the idea generation takes place. Second, we’ll add a check to the
Industry user input to make it a required field.
Altogether, the completed front-end Streamlit code looks like the following, about 20 lines.
st.title("🚀 Startup Idea Generator") form = st.form(key="user_settings") with form: # User input - Industry name industry_input = st.text_input("Industry", key = "industry_input") # Create a two-column view col1, col2 = st.columns(2) with col1: # User input - The number of ideas to generate num_input = st.slider("Number of ideas", value = 3, key = "num_input", min_value=1, max_value=10) with col2: # User input - The 'temperature' value representing the level of creativity creativity_input = st.slider("Creativity", value = 0.5, key = "creativity_input", min_value=0.1, max_value=0.9) # Submit button to start generating ideas generate_button = form.form_submit_button("Generate Idea") if generate_button: if industry_input == "": st.error("Industry field cannot be blank") else: my_bar = st.progress(0.05) st.subheader("Startup Ideas") for i in range(num_input): st.markdown("""---""") startup_idea = generate_idea(industry_input,creativity_input) startup_name = generate_name(startup_idea,creativity_input) st.markdown("##### " + startup_name) st.write(startup_idea) my_bar.progress((i+1)/num_input)
And with that, the final front-end now looks like the following.
3 - Deploy with Streamlit Cloud
Now that our app is ready, let’s deploy it to the web so everyone can start interacting with it. You can deploy the app via your own hosting option, but there’s also a quick and hassle-free way to do it — via Streamlit Cloud.
Streamlit Cloud launches apps directly from a GitHub repository. So, before you can deploy your app, do the following steps.
- Push your code to a GitHub repository
- Sign up for Streamlit Cloud
- Connect your Streamlit Cloud to the GitHub repository
Once you have completed the steps, on your Streamlit Cloud page, click on
You’ll be brought to the
Deploy an app page, where you can select the repository, the branch and the main file path i.e. the code we wrote earlier. You will also need to add your Cohere API key in the
Advanced settings… link (more information here).
And once that is done, click
Deploy!. Wait a few minutes for Streamlit to deploy it, and the app is live. Now literally anyone on the web can access it!
Let’s now take the app for a spin and, say, we want to generate three startup ideas in the productivity industry.
Let’s first try with a low
Creativity setting, of say 0.2, which should give us ideas that are more predictable and possibly more proven. The outcome? It generates ideas revolving around the usual suspects — to-do, time management, and scheduling.
Next, we try with a high
Creativity setting, of say 0.8, which should result in ideas that are more creative but are probably bordering on being too ambitious. This time, the ideas are a lot more diverse — travel planning, diagram drawing, and personal finance.
Here are the screenshots of these generated ideas.
And that concludes our startup idea generator prototype, powered by Cohere and deployed with Streamlit.
This example demonstrated how, using Cohere and Streamlit, you can quickly turn your language AI product idea into a basic prototype. It’s an amazing feeling to be able to deploy a web app without spending long, frustrating hours building a front-end.
We have only covered the surface of what’s possible, though. In this article, we covered the Generate endpoint for generating startup ideas. But there are many more ways how Generate can be applied, such as in this article. Or you can read this article if you’d like to dive deeper into prompt engineering.
Additionally, there are other endpoints you can experiment with, such as Classify and Embed, which you can browse in the Cohere API documentation. Hopefully, these resources can help you start discovering ideas and finding what to build next!
To get started, sign up for the Cohere platform here, free credits included!