Latest / Satellite image deep learning / Chat2Geo and the Power of LLMs

Transcript

Chat2Geo and the Power of LLMs · Satellite image deep learning

• 0:04
  Hello,
• 0:05
  I'm Robin Cole,
• 0:06
  and welcome to the Satellite Image Deep Learning Podcast.
• 0:08
  SPEAKER_00: In this episode,
• 0:09
  SPEAKER_00: I spoke to Shahab Jazdani to learn about Chat2Geo,
• 0:13
  a web-based application designed to simplify remote
• 0:15
  sensing-based geospatial
• 0:17
  SPEAKER_00: analysis through an intuitive chatbot-style interface.
• 0:21
  SPEAKER_00: Large language models,
• 0:22
  SPEAKER_00: such as ChatGPT,
• 0:23
  SPEAKER_00: are reshaping the way users interact with complex datasets,
• 0:27
  and it's inspiring to see innovators like Shahab leverage this
• 0:30
  technology to
• 0:31
  SPEAKER_00: democratize geospatial analytics.
• 0:33
  SPEAKER_00: Note that we also recorded a demonstration video of ChattoGeo,
• 0:37
  SPEAKER_00: which is linked in the show notes.
• 0:39
  SPEAKER_00: Finally,
• 0:39
  SPEAKER_00: if you're watching this on YouTube,
• 0:41
  SPEAKER_00: please consider liking the video and subscribing to the channel,
• 0:44
  SPEAKER_00: as this really helps to reach a wider audience.
• 0:46
  SPEAKER_00: Thank you.
• 0:48
  SPEAKER_00: Bye, Shahab.
• 0:48
  SPEAKER_00: Welcome to the podcast.
• 0:50
  SPEAKER_00: Hello, Robin.
• 0:51
  SPEAKER_00: Thanks for having me.
• 0:52
  SPEAKER_00: It's a pleasure.
• 0:53
  SPEAKER_00: Let's begin with where you work and what you do.
• 0:56
  SPEAKER_01: Yeah, absolutely.
• 0:57
  SPEAKER_01: So I'm the founder at Eurena.
• 1:00
  And I have a master's and bachelor's in geomatics engineering
• 1:05
  and a PhD in physical
• 1:07
  SPEAKER_01: geography,
• 1:08
  SPEAKER_01: all focusing on remote sensing and AI.
• 1:11
  SPEAKER_01: And at GeoRetina,
• 1:13
  we're developing solutions to democratize and simplify complex
• 1:18
  geospatial tasks.
• 1:20
  SPEAKER_01: And a lot of interesting things are going on at GeoRetina.
• 1:25
  SPEAKER_01: And I hope that we can cover some of those things in your podcast.
• 1:29
  SPEAKER_00: Absolutely.
• 1:29
  SPEAKER_00: So I kind of connected with Chat2Gio.
• 1:31
  SPEAKER_00: Do you mind giving us an introduction to that software?
• 1:35
  SPEAKER_00: Absolutely.
• 1:36
  SPEAKER_00: Yeah.
• 1:36
  SPEAKER_01: So Chat2Gio, let me go back and say from where it started.
• 1:42
  So we had the first version of our,
• 1:46
  you know,
• 1:47
  AI platform that we called it Aras.
• 1:51
  SPEAKER_01: And it had,
• 1:52
  SPEAKER_01: you know,
• 1:53
  SPEAKER_01: connection to different sources of remote sensing data,
• 1:56
  SPEAKER_01: connection to geo...
• 1:58
  SPEAKER_01: Google Earth Engine and some other sources.
• 2:01
  SPEAKER_01: And then it uses those information,
• 2:04
  those pieces of information to produce analysis that are often
• 2:09
  difficult to do for
• 2:12
  SPEAKER_01: especially those who don't have geospatial background.
• 2:16
  SPEAKER_01: And it was quite powerful system,
• 2:19
  but we found that people didn't like to get involved in a more
• 2:25
  complex sort of
• 2:27
  SPEAKER_01: interface.
• 2:28
  SPEAKER_01: And they wanted something simpler.
• 2:30
  And then we developed,
• 2:32
  we redesigned and re-architecture everything from scratch.
• 2:37
  SPEAKER_01: And then we found that,
• 2:39
  SPEAKER_01: hey,
• 2:39
  there is ChatGPT and Claude and some other language models out
• 2:47
  there that people
• 2:47
  SPEAKER_01: love and use every day.
• 2:50
  SPEAKER_01: So we decided to build something very, very similar to that.
• 2:54
  SPEAKER_01: but for geospatial tasks.
• 2:57
  SPEAKER_01: And then we started developing the solution.
• 3:01
  SPEAKER_01: And then over time, we iterated over that and then improved it.
• 3:05
  SPEAKER_01: And then we got feedback.
• 3:07
  And then we decided to also publish and release an open source
• 3:13
  version of our
• 3:15
  SPEAKER_01: commercial app,
• 3:16
  SPEAKER_01: which is a chat to geo.
• 3:18
  SPEAKER_01: And the reason that we did that was to make sure that
• 3:21
  you know,
• 3:22
  others who need to build something like that,
• 3:25
  they can start from somewhere.
• 3:27
  And,
• 3:28
  yeah,
• 3:28
  so we can later talk about that and see what are the different
• 3:32
  components of that.
• 3:35
  So you identified this kind of missing piece of tooling that
• 3:38
  you thought others
• 3:39
  SPEAKER_00: would benefit from?
• 3:41
  SPEAKER_01: Absolutely, yeah.
• 3:42
  SPEAKER_01: Especially in the field of geoscience,
• 3:45
  SPEAKER_01: geospatial data science,
• 3:47
  SPEAKER_01: one of the most important things that is missing is having...
• 3:51
  SPEAKER_01: piece of software that can be,
• 3:54
  SPEAKER_01: you know,
• 3:55
  SPEAKER_01: is web native,
• 3:56
  SPEAKER_01: first of all,
• 3:57
  SPEAKER_01: and then it has all the main components of finalized product.
• 4:03
  SPEAKER_01: So that's often missing.
• 4:05
  SPEAKER_01: You see that we have,
• 4:06
  SPEAKER_01: for example,
• 4:06
  SPEAKER_01: as you know,
• 4:07
  SPEAKER_01: QGIS,
• 4:08
  SPEAKER_01: which is the best open source geospatial tool software,
• 4:14
  SPEAKER_01: but web apps,
• 4:15
  SPEAKER_01: we don't have,
• 4:18
  SPEAKER_01: you know,
• 4:18
  SPEAKER_01: all,
• 4:20
  ready to use web apps for users,
• 4:23
  especially those who don't have the technical background.
• 4:27
  And Chat2Gio is actually bringing all those things or putting
• 4:30
  all those things together.
• 4:32
  SPEAKER_00: Right.
• 4:33
  SPEAKER_00: So I opened Chat2Gio.
• 4:35
  SPEAKER_00: What do I see?
• 4:36
  SPEAKER_00: What's the experience?
• 4:39
  SPEAKER_01: So that's a very good question.
• 4:40
  SPEAKER_01: The experience is very, very familiar.
• 4:42
  SPEAKER_01: So it's like you open ChatGPT or Cloud.
• 4:47
  SPEAKER_01: And you can just very quickly start just asking a question.
• 4:53
  SPEAKER_01: And that's one of the most important features of this app.
• 4:56
  SPEAKER_01: We believe that.
• 4:57
  SPEAKER_01: So I have a designer, a web designer expert.
• 5:04
  SPEAKER_01: who is my friend.
• 5:05
  SPEAKER_01: And she says that,
• 5:07
  SPEAKER_01: you know,
• 5:07
  SPEAKER_01: it's always difficult to,
• 5:09
  SPEAKER_01: you know,
• 5:09
  SPEAKER_01: provide training for new users when it comes to,
• 5:13
  SPEAKER_01: you know,
• 5:13
  SPEAKER_01: bringing them on board.
• 5:15
  SPEAKER_01: And we have to minimize that from,
• 5:19
  SPEAKER_01: you know,
• 5:19
  SPEAKER_01: wanting to start using some app and then really use it.
• 5:26
  SPEAKER_01: So for that, we designed the app to be as simple as that.
• 5:31
  SPEAKER_01: So people don't need any training.
• 5:33
  because it's just a simple box and chatbot,
• 5:36
  and then they can start working with that.
• 5:39
  So it's very,
• 5:39
  very familiar for new users and they can just quickly start
• 5:43
  using it.
• 5:44
  SPEAKER_00: Right.
• 5:44
  So the most basic use might be to query some data you've got
• 5:48
  somewhere or do some
• 5:49
  kind of analytic tasks that would otherwise be done with sort
• 5:53
  of point and click
• 5:53
  SPEAKER_00: tools.
• 5:55
  SPEAKER_01: Absolutely.
• 5:56
  SPEAKER_01: Yeah.
• 5:56
  So all those things with a single prompt can be done without
• 6:00
  doing any specific clicking.
• 6:03
  SPEAKER_01: And then they can get that and then they can ask follow-up questions.
• 6:07
  SPEAKER_01: So it puts together all the previous questions and responses together.
• 6:14
  SPEAKER_01: And then it has the context required for answering subsequent questions.
• 6:19
  SPEAKER_00: Right, okay.
• 6:20
  SPEAKER_00: And obviously ChatGPT is on OpenAI server somewhere.
• 6:24
  SPEAKER_00: My data might be on my laptop or some database somewhere.
• 6:26
  SPEAKER_00: How do you connect and bridge these different pieces of information?
• 6:32
  SPEAKER_01: Yeah, that's interesting.
• 6:34
  SPEAKER_01: So we have three main sources of data that we use throughout this app.
• 6:42
  The first one is satellite data that come from,
• 6:46
  for this case,
• 6:48
  come from Google Earth Engine.
• 6:52
  SPEAKER_01: So that's the main piece.
• 6:54
  SPEAKER_01: The second one is the data that users upload to the system.
• 6:59
  SPEAKER_01: So this is, we can break it into two pieces.
• 7:03
  SPEAKER_01: One is the region of interest that they select.
• 7:07
  SPEAKER_01: They can drag and drop the regions of interest like GeoJSON or shapefile.
• 7:13
  SPEAKER_01: And then all the analysis will be done within those regions of interest.
• 7:19
  SPEAKER_01: And the third one,
• 7:20
  SPEAKER_01: which is actually part of the previous one,
• 7:23
  SPEAKER_01: is the textual data,
• 7:25
  SPEAKER_01: the non-spatial data,
• 7:27
  SPEAKER_01: like reports,
• 7:30
  SPEAKER_01: policies,
• 7:31
  SPEAKER_01: and everything that is not spatial.
• 7:34
  SPEAKER_01: They can also just drag and drop those
• 7:38
  pieces of information into the system and then integrate them
• 7:42
  with their geospatial
• 7:44
  SPEAKER_01: analysis results.
• 7:46
  SPEAKER_01: And that's what we call the knowledge base,
• 7:49
  which is a RAG-based system that just queries large documents
• 7:55
  easily for users.
• 7:58
  And I want to dig into what RAG is because it's an acronym I
• 8:02
  see all over the place.
• 8:03
  SPEAKER_00: But does that mean I literally upload all my documents of every prompt?
• 8:07
  SPEAKER_00: Is there some other process to get that context into the queries?
• 8:12
  SPEAKER_01: Yeah,
• 8:13
  SPEAKER_01: so before,
• 8:15
  SPEAKER_01: so the way that it works is that you have several documents,
• 8:20
  SPEAKER_01: often thousands of pages,
• 8:22
  and then you just send them or upload or stream all those
• 8:27
  documents into an LLM.
• 8:30
  SPEAKER_01: So what the LLM does is that it encodes those letters,
• 8:35
  SPEAKER_01: words,
• 8:36
  SPEAKER_01: and everything to just find the numbers.
• 8:39
  SPEAKER_01: And then those encoded
• 8:43
  SPEAKER_01: numbers or values are stored in a vector database.
• 8:47
  So it's like a database,
• 8:49
  but it's vector because of those numbers that are vector-like.
• 8:54
  SPEAKER_01: And then whenever that you ask a question,
• 8:58
  SPEAKER_01: again,
• 8:58
  your question is fed into the LLM and the encoding again is
• 9:04
  done on your question,
• 9:07
  SPEAKER_01: and then it will be sent to the vector database.
• 9:10
  SPEAKER_01: and it's queried from the vector database.
• 9:13
  SPEAKER_01: And then the encoded results will come back and then decode it for you.
• 9:19
  SPEAKER_01: So it's a very interesting process.
• 9:22
  SPEAKER_01: It's not complicated, but that's the beauty of this.
• 9:26
  SPEAKER_01: But this is just the simplest form of a RAC system.
• 9:31
  SPEAKER_00: Right, and what are the limits to it?
• 9:32
  SPEAKER_00: Can this database get massive or how does that system scale?
• 9:38
  Yeah,
• 9:38
  so that's one of the good features of RAG systems that you can
• 9:45
  scale them easily.
• 9:47
  But the main problem is that the way that you structure it and
• 9:54
  then extract the
• 9:55
  SPEAKER_01: information from it,
• 9:57
  SPEAKER_01: which is called chunk by chunk based extraction or structure.
• 10:03
  It's dependent on the data that you have,
• 10:07
  the context,
• 10:08
  the documents that you have.
• 10:09
  Sometimes it's like an essay that individual parts components
• 10:14
  are not important,
• 10:15
  SPEAKER_01: but the main context is more important.
• 10:17
  So the way that you create or encode your documents in this
• 10:21
  rack system is
• 10:23
  SPEAKER_01: different from the case where every paragraph
• 10:26
  SPEAKER_01: could have a different piece of information from the other ones.
• 10:31
  And then if you increase the context or those chunk sizes,
• 10:36
  you may lose information.
• 10:38
  So sometimes it's very document dependent and you have to take
• 10:43
  that into account.
• 10:45
  Otherwise you will get some hallucinated responses or wrong
• 10:50
  responses coming from
• 10:51
  SPEAKER_01: other places that are irrelevant.
• 10:54
  SPEAKER_00: Yeah.
• 10:55
  SPEAKER_00: I'd imagine that.
• 10:55
  SPEAKER_00: ChatGPT, it's been exposed to many documents on the internet.
• 10:59
  SPEAKER_00: Geospatial documents might have their own structure.
• 11:02
  SPEAKER_00: Maybe they're referencing images and maps and things like that.
• 11:05
  Is the process going to be the same for sort of geospatial data
• 11:08
  as it is for other
• 11:10
  SPEAKER_00: kinds of reports?
• 11:13
  SPEAKER_01: Could be,
• 11:14
  SPEAKER_01: you know,
• 11:15
  SPEAKER_01: one of the,
• 11:16
  SPEAKER_01: for example,
• 11:17
  SPEAKER_01: the,
• 11:18
  SPEAKER_01: for example,
• 11:19
  SPEAKER_01: tabular data,
• 11:20
  SPEAKER_01: one of the challenges is that connecting,
• 11:25
  SPEAKER_01: for example,
• 11:25
  SPEAKER_01: we have databases for tabular data that can be easily,
• 11:28
  SPEAKER_01: you know,
• 11:29
  SPEAKER_01: queried.
• 11:30
  SPEAKER_01: For textual data, for example, documents, when we want to query them,
• 11:37
  SPEAKER_01: It's often very complex because,
• 11:40
  SPEAKER_01: you know,
• 11:41
  the way that the paragraphs are structured and the documents
• 11:45
  and geospatial
• 11:46
  SPEAKER_01: information in them are provided,
• 11:48
  SPEAKER_01: it could be complex,
• 11:49
  SPEAKER_01: maps and other things may not be queryable easily.
• 11:53
  SPEAKER_01: But for this system that we have,
• 11:56
  SPEAKER_01: It's not necessarily geospatial information in those documents,
• 12:00
  SPEAKER_01: but rather some other types of information that could be useful.
• 12:05
  SPEAKER_01: But there are systems that you can have also maps,
• 12:09
  SPEAKER_01: embedded maps into documents,
• 12:11
  SPEAKER_01: and they can also interpret those maps
• 12:14
  SPEAKER_01: and then create more intuitive, more enriched experience for users.
• 12:19
  SPEAKER_00: Yeah, fantastic.
• 12:20
  SPEAKER_00: So you can connect to your documents.
• 12:22
  SPEAKER_00: You can connect to Earth Engine.
• 12:24
  SPEAKER_00: Can I connect to an arbitrary database that I've got?
• 12:28
  SPEAKER_01: Yes.
• 12:28
  SPEAKER_01: So, for example, we have Esri's feature service that you can connect to.
• 12:37
  SPEAKER_01: We're also adding Postgres connection.
• 12:41
  SPEAKER_01: So if you have your Postgres somewhere,
• 12:43
  SPEAKER_01: you can connect it to this system,
• 12:46
  SPEAKER_01: perhaps first on GCP,
• 12:49
  SPEAKER_01: Bedrock,
• 12:49
  SPEAKER_01: Amazon,
• 12:50
  SPEAKER_01: or some other places.
• 12:52
  But this system has been designed in a way that you can easily
• 12:59
  scale it in terms of
• 13:00
  SPEAKER_01: the databases and integrations that you may want to have.
• 13:04
  SPEAKER_00: Interesting.
• 13:05
  SPEAKER_00: I've been hearing a lot about MCP.
• 13:07
  I'm curious if that's the approach you use or even just to get
• 13:10
  your thoughts on that.
• 13:12
  SPEAKER_01: Yeah, so MCP, I think it's one of those very high topics recently.
• 13:19
  SPEAKER_01: So we're not using that, but we are going to use that soon.
• 13:22
  SPEAKER_01: It's on our road plan.
• 13:25
  SPEAKER_01: But MCP,
• 13:26
  SPEAKER_01: I think it's perhaps many still don't know how it can be used,
• 13:32
  SPEAKER_01: but it's a very,
• 13:33
  SPEAKER_01: very powerful protocol that saves us a lot of time.
• 13:39
  SPEAKER_01: And why is that important?
• 13:40
  Because you may have those APIs that you want to integrate with
• 13:46
  your language-based
• 13:48
  SPEAKER_01: system,
• 13:49
  SPEAKER_01: and then those APIs always change,
• 13:51
  SPEAKER_01: and then they may break your system.
• 13:54
  SPEAKER_01: But with MCP,
• 13:56
  SPEAKER_01: what happens is that you don't need to be concerned about that anymore,
• 14:01
  SPEAKER_01: because those APIs automatically will be updated,
• 14:04
  SPEAKER_01: and it's like you always access the signature
• 14:08
  SPEAKER_01: of those APIs, not actually how they are implemented.
• 14:14
  SPEAKER_01: So MCP gives you a way to access up-to-date APIs,
• 14:21
  SPEAKER_01: but not the details,
• 14:23
  SPEAKER_01: how they are implemented,
• 14:24
  SPEAKER_01: but the signature of those APIs.
• 14:27
  SPEAKER_01: That are often,
• 14:28
  SPEAKER_01: this is not our responsibility to keep them updated,
• 14:31
  SPEAKER_01: but the responsibility of the publishers of those APIs,
• 14:34
  SPEAKER_01: like GitHub,
• 14:35
  SPEAKER_01: like OneDrive,
• 14:36
  SPEAKER_01: et cetera.
• 14:38
  SPEAKER_00: I think there's another point kind of implicit there.
• 14:40
  SPEAKER_00: You said that it's not something you use at the moment.
• 14:42
  SPEAKER_00: You're obviously doing something slightly different.
• 14:44
  You're going to bring in all of these technologies are evolving
• 14:47
  at a very rapid pace.
• 14:48
  SPEAKER_00: What's it like to kind of try and develop against that?
• 14:52
  SPEAKER_01: Oh, yeah.
• 14:52
  SPEAKER_01: So that's really challenging, you know.
• 14:55
  SPEAKER_01: So we have heard about a cursor, the AI IDE.
• 15:01
  SPEAKER_01: And one of the main things or one of the most important things that made
• 15:06
  to have $200 million ARR is that they are rapidly adding the
• 15:14
  new advances in AI to
• 15:17
  SPEAKER_01: their system,
• 15:18
  SPEAKER_01: to their IDE,
• 15:19
  SPEAKER_01: which is actually under the hood is VS Code.
• 15:24
  And that's something that has separated them from the
• 15:28
  competition like Winsurf.
• 15:31
  SPEAKER_01: But it's very,
• 15:31
  very challenging for smaller teams like us to keep up with the
• 15:36
  new technologies,
• 15:36
  SPEAKER_01: new advances.
• 15:38
  But we try to just handpick those features that are really
• 15:43
  powerful and useful for
• 15:46
  SPEAKER_01: us even in the future,
• 15:48
  not just bringing every new things into the system because we
• 15:51
  think that that's a
• 15:52
  SPEAKER_01: new thing.
• 15:53
  SPEAKER_00: Right.
• 15:54
  So keeping up to date with what people are using and what's
• 15:58
  impactful and then
• 16:00
  SPEAKER_00: cautiously adopting as validated.
• 16:03
  SPEAKER_00: Right.
• 16:04
  SPEAKER_01: Absolutely,
• 16:05
  SPEAKER_01: yeah,
• 16:05
  because I think that over time it will also help us maintain
• 16:09
  the code base more
• 16:11
  SPEAKER_01: efficiently and connect new features to the system faster.
• 16:18
  SPEAKER_00: Yeah, I'd love to dive a bit more into the development side.
• 16:21
  SPEAKER_00: You obviously mentioned cursor as a tool for...
• 16:24
  SPEAKER_00: you know,
• 16:24
  SPEAKER_00: writing the code,
• 16:26
  SPEAKER_00: how deep does it go,
• 16:27
  SPEAKER_00: the sort of automation that's possible with a tool like Cursor?
• 16:30
  SPEAKER_00: Can I test my code?
• 16:31
  SPEAKER_00: Can I run different versions of it?
• 16:33
  SPEAKER_00: Have the tool kind of interact with it?
• 16:37
  SPEAKER_01: Yeah, so I have used Cursor a lot, to be honest.
• 16:43
  SPEAKER_01: I have used the different IDs, AI IDs, Zed, Windsurf, Cursor.
• 16:49
  SPEAKER_01: With Cursor, it can go very deep into your code base.
• 16:54
  SPEAKER_01: It can write tests, unit tests or other types of tests.
• 16:59
  SPEAKER_01: It can make, add new features if you want to, it can debug your code.
• 17:06
  SPEAKER_01: But something that I found very,
• 17:10
  SPEAKER_01: not annoying,
• 17:11
  but not really well developed yet or well designed yet is that
• 17:16
  if you don't provide
• 17:17
  SPEAKER_01: it with enough information,
• 17:18
  SPEAKER_01: enough context,
• 17:20
  SPEAKER_01: something like,
• 17:21
  SPEAKER_01: something called cursor rules,
• 17:23
  SPEAKER_01: which are just system prompts for the LLM.
• 17:27
  SPEAKER_01: It can break your architecture.
• 17:29
  SPEAKER_01: It can create folders that are irrelevant.
• 17:33
  SPEAKER_01: And if you don't care about those things,
• 17:36
  SPEAKER_01: at the end,
• 17:37
  you may end up with a project that is very messy and very
• 17:40
  difficult to maintain and
• 17:42
  SPEAKER_01: could be prone to bugs.
• 17:44
  SPEAKER_01: But it's very, very useful.
• 17:46
  SPEAKER_01: It can improve your efficiency or productivity.
• 17:50
  if you just know how to interact with it or something which is
• 17:56
  called prompt engineering.
• 17:57
  So you tell it what it should do,
• 18:00
  otherwise it will do things that should not be done.
• 18:04
  SPEAKER_00: Yeah.
• 18:04
  And I assume that this will be applicable to the kind of
• 18:07
  analytics people will do
• 18:08
  SPEAKER_00: with ChattoGio as well.
• 18:10
  There'll be a bit of expertise in crafting the right prompt,
• 18:13
  knowing the system,
• 18:14
  et cetera.
• 18:16
  SPEAKER_01: Exactly, yes.
• 18:17
  SPEAKER_01: So last week I got
• 18:20
  feedback from one of our users that it would be nice if the
• 18:23
  system had this feature.
• 18:25
  SPEAKER_01: And I said that this is not the goal of this system.
• 18:29
  SPEAKER_01: It's actually designed for these applications, not that application.
• 18:35
  SPEAKER_01: So they should,
• 18:36
  SPEAKER_01: users,
• 18:36
  SPEAKER_01: as you said,
• 18:37
  have to have some kind of basic context about what this tool is
• 18:43
  going to do and
• 18:44
  SPEAKER_01: what would be the results that they will receive from the system.
• 18:47
  SPEAKER_00: Yeah.
• 18:48
  SPEAKER_00: One final point.
• 18:49
  SPEAKER_00: Have you thought about kind of novel ways of documenting the systems?
• 18:53
  For example,
• 18:54
  I've seen people generate videos just from code bases or
• 18:58
  podcasts.
• 18:58
  SPEAKER_00: Is that something that's crossed your mind or something you've looked at?
• 19:04
  SPEAKER_01: Absolutely.
• 19:05
  SPEAKER_01: So I love teaching.
• 19:08
  SPEAKER_01: So I think that now that we have the open source version of this app,
• 19:15
  SPEAKER_01: I think that if I have the time,
• 19:17
  SPEAKER_01: I want to,
• 19:18
  SPEAKER_01: you know,
• 19:18
  SPEAKER_01: publish some videos,
• 19:20
  SPEAKER_01: tutorials on how we started this app,
• 19:23
  SPEAKER_01: how we developed it and the different pieces together,
• 19:25
  and also bring on some kind of the applications of these AI
• 19:30
  systems like cursor and
• 19:33
  SPEAKER_01: how we can efficiently use them.
• 19:35
  I think,
• 19:36
  as you said,
• 19:37
  the pace of,
• 19:38
  you know,
• 19:38
  advances in AI is crazy these days.
• 19:42
  SPEAKER_01: And there are many people who are interested,
• 19:45
  SPEAKER_01: but because of many reasons,
• 19:46
  SPEAKER_01: they don't have their sources to find those specific information.
• 19:50
  SPEAKER_01: And publishing videos like that would be really important.
• 19:54
  SPEAKER_01: And I think that, yes, in the future, I will also do that.
• 19:57
  SPEAKER_00: Good stuff.
• 19:58
  SPEAKER_00: Looking forward to seeing what you do there.
• 20:01
  SPEAKER_00: Really fascinating conversation.
• 20:03
  I think LLMs are going to have a huge impact on many areas from
• 20:06
  the development to
• 20:07
  the use of these tools and exciting to hear from somebody
• 20:10
  that's at the forefront
• 20:11
  SPEAKER_00: of that.
• 20:12
  SPEAKER_00: We're going to jump onto a demonstration video,
• 20:15
  SPEAKER_00: which will be a separate recording from this one.
• 20:18
  SPEAKER_00: But just to wrap things up there,
• 20:19
  I just want to hear what's the most surprising thing or
• 20:22
  delightful thing you've
• 20:23
  SPEAKER_00: heard somebody use chat to Geo for?
• 20:27
  SPEAKER_01: Yeah,
• 20:27
  so I think that one of the most positive feedback that we got
• 20:33
  was that how easy it
• 20:35
  SPEAKER_01: is to just use this system,
• 20:36
  SPEAKER_01: how fast it is,
• 20:38
  SPEAKER_01: and how intuitive this system is.
• 20:41
  SPEAKER_01: And we always strive to make it more user-friendly for users,
• 20:45
  SPEAKER_01: but still we got this positive feedback that we always wanted.
• 20:50
  SPEAKER_01: that people have when using Chat2Geo that it's simple.
• 20:55
  SPEAKER_01: It's not, you know, there are not a lot of buttons.
• 20:57
  SPEAKER_01: It has a very familiar interface.
• 21:00
  SPEAKER_00: I'm reminded of that Steve Jobs quote about,
• 21:02
  SPEAKER_00: you know,
• 21:03
  SPEAKER_00: using Windows and then,
• 21:04
  SPEAKER_00: you know,
• 21:06
  using iOS is like having a glass of cold water when you're
• 21:08
  going through hell.
• 21:10
  SPEAKER_00: That can be the best.
• 21:11
  SPEAKER_00: The user experience can be the best compliment, I think.
• 21:13
  SPEAKER_00: So that's great to hear.
• 21:14
  SPEAKER_00: Well, thanks again.
• 21:16
  SPEAKER_00: Looking forward to catching up for the demo in the next video.
• 21:19
  SPEAKER_00: Lastly, if people want to follow your updates, what's the best platform?
• 21:23
  Right now on LinkedIn,
• 21:24
  but I'm going to be more active on X sometimes soon.
• 21:28
  SPEAKER_00: Right.
• 21:28
  SPEAKER_00: Okay.
• 21:29
  SPEAKER_00: We'll have a bit of company on X at last.
• 21:31
  SPEAKER_00: Good to hear.
• 21:32
  SPEAKER_00: Okay.
• 21:32
  SPEAKER_00: Well, once again, thank you.
• 21:34
  SPEAKER_00: And hopefully people will join us on the demonstration video.
• 21:37
  SPEAKER_00: Thank you so much, Robbie.
• 21:39
  SPEAKER_01: Yeah.
• 21:39
  SPEAKER_00: Thank you.