Transcription: OpenAgents Episode 010 - Connecting to Vectara
June 9, 2026 ยท View on GitHub
Source: https://twitter.com/OpenAgentsInc/status/1723203092647137636 Wiki source: https://raw.githubusercontent.com/wiki/OpenAgentsInc/openagents/Video-Series.md Media title: OpenAgents - Episode 010: Connecting to Vectara To work magic with our uploaded PD... Upload date: 20231111 Transcription model: gpt-4o-transcribe-diarize Generated at: 2026-06-01T01:46:01Z
Machine-generated transcript. Review speaker labels and wording before using this as quote-grade source material.
[00:00] Christopher David: all right we got a pretty nice interface here open agents dot app see what's cooking drag
[00:09] Christopher David: i know that was kind of weird last video because i had it not sharing the whole screen just the current application drop it boom so
[00:20] Christopher David: we've got the file uploading api connected we don't have the
[00:25] Christopher David: message sending fully connected because we first want to figure out what we're actually going to do with this PDF.
[00:34] Christopher David: I have previously tested this service called Vectora and that's what we're going to use.
[00:45] Christopher David: We have the option of like doing our own retrieval augmented generation algorithms over the documents that we're uploading.
[00:54] Christopher David: we're using Postgres so we could embed this using our GP Utopia embedding endpoint and save the embeddings and do RAG over that.
[01:03] Christopher David: And I think that's something that we'll do in a future video.
[01:06] Christopher David: I first just want to take the absolute shortest path to getting something meaningful happening with this PDF.
[01:14] Christopher David: And for that I'm going to integrate with a service that I have used before called Vectara.
[01:22] Christopher David: I guess let's learn about what Vectara is.
[01:33] Christopher David: Yeah,
[01:33] Christopher David: I don't know what all that stuff is.
[01:36] Christopher David: Okay,
[01:36] Christopher David: so Vectara automatically extracts text from PDF and
[01:47] Christopher David: code,
[01:47] Christopher David: index,
[01:48] Christopher David: retrieve,
[01:48] Christopher David: rerank, summarize.
[01:56] Christopher David: Yeah, so basically lets you ask a question and then you get back responses grounded in the text with like the context around that.
[02:09] Christopher David: Probably better if I just show
[02:13] Christopher David: you.
[02:15] Christopher David: I uploaded a PDF of the Seasteading book.
[02:21] Christopher David: Can I summarize the whole thing?
[02:28] Christopher David: No.
[02:30] Christopher David: Tell me about Megaports.
[02:38] Christopher David: Megaports play a crucial role in global trade and can contribute to a country's wealth.
[02:43] Christopher David: They serve as hubs for cargo transfer and are connected to the global trade network.
[02:48] Christopher David: Citation.
[02:50] Christopher David: Building larger floating harbors offshore can expand the capabilities of existing ports and improve efficiency.
[02:57] Christopher David: Cruise ships rarely stay in ports overnight and instead drop off passengers,
[03:01] Christopher David: pick up supplies and continue their journey.
[03:02] Christopher David: Citation.
[03:03] Christopher David: And the citations look like some kind of store score.
[03:10] Christopher David: It kind of like crunches all of the context and then puts it into like a nice.
[03:18] Christopher David: answer like really grounded in just the source material with no hallucination or other context so
[03:32] Christopher David: really that's all I want if I can get this type of summary this type of question and answer over the documents that people are uploading
[03:45] Christopher David: In our interface, as simple as this,
[03:49] Christopher David: that would be a great start.
[03:51] Christopher David: That's something that would provide immediate value for people.
[03:56] Christopher David: So let's do that.
[03:57] Christopher David: So in this video, we're going to build up probably like a service within our OpenAgents code
[04:06] Christopher David: base,
[04:06] Christopher David: probably like a class for interacting with Vektara.
[04:09] Christopher David: We will learn how to interact with a third-party service via our API. We'll reason about maybe best practices for integrating with third-party APIs generally because there's going to be probably a number of these that we integrate with.
[04:27] Christopher David: And I've played with this a little bit, but I haven't done anything really with their API.
[04:32] Christopher David: So it'll be maybe helpful for some of you developers to see how I consume an API.
[04:39] Christopher David: So let's learn about it.
[04:41] Christopher David: Everything in Vectara is driven by APIs.
[04:43] Christopher David: This section serves as a roadmap to understanding and using our gRPC APIs and REST APIs.
[04:48] Christopher David: We'll stick with REST for now.
[04:58] Christopher David: The file upload API,
[05:00] Christopher David: I'm going to guess that we'll need that.
[05:02] Christopher David: So let's do a new page.
[05:05] Christopher David: Called Vektara integration file
[05:13] Christopher David: upload API will need that one
[05:22] Christopher David: You upload an index documents into a corpus and then you query the corpus
[05:33] Christopher David: And we might see if ChatGPT can help us with consuming this particular document.
[05:51] Christopher David: And then let's build this up via test-driven development.
[05:59] Christopher David: Call this VicTara test.
[06:08] Christopher David: What are our tests going to be?
[06:18] Christopher David: Can upload file to
[06:21] Christopher David: Vectara.
[06:24] Christopher David: And see how Copilot kind of wants us to just do it via an API.
[06:27] Christopher David: We're not going to do it via API. We're going to be like doing this as like a service call within the probably within the file controller. So what happens when.
[06:36] Christopher David: file is uploaded we do this right now we're just storing the file locally on our server and that's all we're doing so instead we'd probably do like yeah
[06:51] Christopher David: send file to Victoria and
[06:55] Christopher David: then save
[07:00] Christopher David: something in our local database
[07:03] Christopher David: that's relevant from that I don't know and we will do that probably by doing something like you know vectora equals new vectora vectora upload file yeah something like that so this is the kind of syntax that we're going to be doing so in here we'll probably do let's see if copilot can remember
[07:31] Christopher David: No.
[07:31] Christopher David: So we'll do Victara equals,
[07:34] Christopher David: oh, Mockery Mock. I don't know what that does.
[07:37] Christopher David: New Victara.
[07:40] Christopher David: Victara upload file. Now how do we mock files?
[07:46] Christopher David: In Laravel, copy, paste, copy, paste,
[07:49] Christopher David: copy, paste.
[07:51] Christopher David: Here we go.
[07:52] Christopher David: Fake a
[08:00] Christopher David: uploaded file
[08:08] Christopher David: called document dot PDF and then upload it and
[08:18] Christopher David: then I don't know what our upload response is going to be but I am going to expect upload response
[08:30] Christopher David: Expect upload response okay to be true.
[08:46] Christopher David: That's probably a good start.
[08:48] Christopher David: So let's try it.
[08:51] Christopher David: What's going to happen?
[08:56] Christopher David: Of course, class vector not found. So.
[09:00] Christopher David: Let's create the Vectora class where we'll put our Vectora logic.
[09:07] Christopher David: And I'll put that in a services folder.
[09:13] Christopher David: Vectora.
[09:15] Christopher David: B_H_P_
[09:17] Christopher David: namespace
[09:20] Christopher David: app services class.
[09:26] Christopher David: Vectora public function upload cool and
[09:34] Christopher David: since we want to just make this pass return okay true class
[09:44] Christopher David: Vectora not found let's import it I don't know why our autocomplete is not working it's pretty annoying use app
[09:53] Christopher David: Services Vectara.
[09:56] Christopher David: All right, our test passes. We're done.
[10:00] Christopher David: No, we're not done.
[10:22] Christopher David: See if ChatGP can help us.
[10:25] Christopher David: I'll be very excited to ask GPTopia to help us. We could probably do that now.
[10:30] Christopher David: But let's try this.
[10:33] Christopher David: Help me build a PHP class for integrating Vektara into my AI chatbot app.
[10:45] Christopher David: I'm using Laravel.
[10:53] Christopher David: This test must pass.
[11:01] Christopher David: Here is where I need the code.
[11:06] Christopher David: Next I will share with you the Vectara file upload API doc and so you can write the function.
[12:08] Christopher David: Looks pretty good.
[12:11] Christopher David: Clean interface.
[12:13] Christopher David: They're not wasting all their money.
[12:17] Christopher David: So JWT token.
[12:38] Christopher David: Code samples.
[12:46] Christopher David: Now here it says API key,
[12:48] Christopher David: so I don't know why it's asking me about JWT.
[13:10] Christopher David: Here is their sample PHP code. I note it uses an API key,
[13:17] Christopher David: not a JWT.
[13:21] Christopher David: Would you modify our Vectara class based on this?
[13:33] Christopher David: Okay, let's get us an API key.
[13:37] Christopher David: Which I might already have
[14:05] Christopher David: I wanted to have access to all the corpora. Do I need to create a corpora in advance?
[14:18] Christopher David: Okay.
[14:23] Christopher David: That doesn't seem right.
[14:24] Christopher David: I need to assign it to a corpora, but I need to be able to create a corpus from a file.
[14:34] Christopher David: So I can't pre-create it.
[15:40] Christopher David: Get JWT token dot PHP.
[15:44] Christopher David: What the hell is that?
[15:56] Christopher David: I should be able to just give it an API token.
[16:32] Christopher David: I need to create a corpus. This operation authenticates with an OAuth 2.0 bearer token via the client credentials grant.
[16:46] Christopher David: That does not sound like what I need.
[17:19] Christopher David: The problem is that API keys seem to require
[17:26] Christopher David: pre-existing seem to require access to a specific corpus.
[17:36] Christopher David: And I need to be able to programmatically create a corpus for
[17:44] Christopher David: each file that's uploaded.
[17:49] Christopher David: or for each user that uploads a file.
[18:40] Christopher David: Bruh. They're calling them admin APIs.
[18:50] Christopher David: Are you saying I can't do it with
[18:55] Christopher David: an API key?
[20:03] Christopher David: But I don't see examples in their code of being able to create a corpus using the API key only, the JWT,
[20:12] Christopher David: from some off flow I don't understand how to integrate with what I'm trying to do.
[20:23] Christopher David: Here's the create corpus API doc.
[21:02] Christopher David: Well, maybe it's as simple as doing this.
[21:07] Christopher David: Let's try...
[21:12] Christopher David: Let's try this.
[21:16] Christopher David: Let's try adapting this getJWTToken sample code of theirs into our Vectara class. Maybe?
[21:26] Christopher David: I don't know that much about OAuth. Just in the...
[21:30] Christopher David: Times I've used it in the past I associate it with like pain in the ass redirects and stuff
[21:59] Christopher David: copy paste so let's see if this does anything off
[22:15] Christopher David: URL
[22:43] Christopher David: What's the off URL?
[23:01] Christopher David: Authentication URL for this customer.
[23:06] Christopher David: Presumably that's
[23:11] Christopher David: Ah, here we go.
[23:17] Christopher David: Okay,
[23:18] Christopher David: so as long as it can happen behind the scenes, then it's fine.
[23:20] Christopher David: So here's the - that's
[23:27] Christopher David: the OAuth URL.
[23:27] Christopher David: Okay.
[23:37] Christopher David: Client ID,
[23:38] Christopher David: client secret.
[23:40] Christopher David: Okay.
[23:43] Christopher David: Alright, app client.
[23:46] Christopher David: Open agents.
[23:49] Christopher David: Select roles.
[23:50] Christopher David: Corpus admin.
[23:56] Christopher David: Okay.
[24:01] Christopher David: Alright, so let's just hard code this stuff for now.
[24:06] Christopher David: Auth URL.
[24:12] Christopher David: Does the client ID?
[24:21] Christopher David: I'm guessing that's the client ID.
[24:27] Christopher David: And that's the client secret.
[24:31] Christopher David: Okay.
[24:33] Christopher David: All right, as long as I've got stuff to plug in and then you'll just give me a token.
[24:38] Christopher David: So,
[24:42] Christopher David: I don't actually need to pass anything to it.
[24:53] Christopher David: So I guess the first thing I want to test is can
[25:00] Christopher David: get GWT.
[25:06] Christopher David: What does that do?
[25:16] Christopher David: Now let's make it public for now.
[25:21] Christopher David: Expecting null to not be null.
[25:30] Christopher David: Let's see what our response is.
[25:35] Christopher David: Bad request.
[25:41] Christopher David: Deny.
[25:52] Christopher David: Can I get a simpler response?
[25:58] Christopher David: No.
[26:00] Christopher David: What am I missing?
[26:18] Christopher David: It threw on this whole thing, I don't want that.
[26:21] Christopher David: If it's going to be a pending auth2 token right there.
[26:26] Christopher David: Hooray! Access token!
[26:32] Christopher David: Booyah! Can get JWT token.
[26:34] Christopher David: Okay,
[26:35] Christopher David: this is now doable.
[27:27] Christopher David: Create corpus. Corpus data.
[28:12] Christopher David: Well, can create corpus.
[28:42] Christopher David: Is this just bullshitting now?
[28:43] Christopher David: Let me saw this.
[28:55] Christopher David: It seems like you must be bullshitting.
[29:02] Christopher David: You must be bullshitting.
[29:08] Christopher David: But I'm curious to see how long you'll bullshit.
[29:22] Christopher David: Text wrap wrap.
[29:23] Christopher David: Oh yeah, the customer logo text wrap wrap height.
[29:25] Christopher David: Okay. Um
[29:28] Christopher David: Creating a corpus via API.
[29:39] Christopher David: Here we go.
[29:42] Christopher David: Corpus data, name, description. That works for me.
[30:05] Speaker B: What is one?
[30:40] Christopher David: Just for now I'm going to comment this out, make sure we're not rate limited or whatever.
[30:46] Christopher David: Oh, customer ID.
[30:53] Christopher David: Alright, let's die and dump our response.
[31:07] Christopher David: Request does not contain Customer ID bin header.
[31:11] Christopher David: That's interesting.
[31:38] Christopher David: Maybe.
[31:41] Christopher David: Failed to retrieve customer.
[31:43] Christopher David: Oh.
[31:45] Christopher David: Is that... Oh,
[31:46] Christopher David: that's probably my singular customer ID right there.
[31:55] Christopher David: Because this is all going to go into my account.
[32:01] Christopher David: Corpus created.
[32:02] Christopher David: Bingo.
[32:05] Christopher David: Now, did that create it in my account here?
[32:13] Christopher David: There it is,
[32:14] Christopher David: test corpus.
[32:16] Christopher David: Very nice.
[32:21] Christopher David: Now, ideally there'd be a test mode so I wouldn't create actual corpuses during the test because I'm going to be running this a lot.
[32:29] Christopher David: We could also test the delete corpus and delete the same one that we created.
[32:36] Christopher David: But the main thing for our purposes is that we
[32:42] Christopher David: like actually get it to work.
[32:49] Christopher David: Can create corpus.
[33:05] Christopher David: We can get JWT token, can create corpus, next we want to upload a file.
[33:15] Christopher David: JWT token is...
[33:36] Christopher David: Let's go back to ChachiBT and say this works so far. Now please add the upload function.
[34:08] Christopher David: Am I accumulating corpuses in here?
[34:16] Christopher David: Very nice.
[34:20] Christopher David: So we'll do like one user can have multiple corpuses.
[34:33] Christopher David: So the upload.
[34:35] Christopher David: function
[35:03] Christopher David: What's all that C and O stuff?
[35:05] Christopher David: Oh,
[35:05] Christopher David: that is what it needs to be.
[35:15] Christopher David: Okay.
[35:17] Christopher David: Customer ID should not be passed in.
[35:31] Christopher David: condensed to that.
[35:42] Christopher David: And I'll remove it from there.
[35:50] Christopher David: Customer ID stays the same.
[36:00] Christopher David: Dark metadata, that's cool to have an optional thing there.
[36:05] Christopher David: Uploaded file.
[36:13] Christopher David: Haven't used that before.
[36:22] Christopher David: Okay, so let's try uploading a file to our, like, corpus ID number four.
[36:31] Christopher David: So upload four and file.
[36:36] Christopher David: Hopefully
[36:38] Christopher David: that's all we would need.
[36:47] Christopher David: Undefined variable customer ID.
[36:52] Christopher David: Oh.
[36:54] Christopher David: Hmm. And what's that twice?
[36:56] Christopher David: Hmm.
[37:02] Christopher David: A content key is required.
[37:18] Christopher David: What are you basing that on?
[37:22] Christopher David: I don't see that in your example code at all.
[37:32] Christopher David: Coming from multi-part stream, maybe?
[37:49] Christopher David: So let's do this.
[37:54] Christopher David: Here's my code.
[38:00] Christopher David: Here's my test.
[38:17] Christopher David: It fails with this.
[38:37] Christopher David: Yeah, that's what I figured.
[39:06] Christopher David: That would be nice, if it just worked.
[39:25] Christopher David: No.
[39:34] Christopher David: Maybe it's because that doesn't work with uh the marked data.
[39:40] Christopher David: Or
[39:44] Christopher David: because I'm faking the file.
[40:08] Christopher David: Out of curiosity,
[40:09] Christopher David: let me die and dump this file and see what it even looks like.
[40:24] Christopher David: Should there be something that says contents? Because I don't see anything.
[40:39] Christopher David: Is it because the file is a faked file with this structure?
[40:56] Christopher David: Like should I use an actual file?
[41:23] Christopher David: directly use the file stream I
[41:30] Christopher David: don't think there's gonna be a get real path right
[41:38] Christopher David: yeah I should probably use an actual an actual file to test I'm just curious to see if this makes any difference
[42:17] Christopher David: Document metadata expected a unitary JSON object.
[42:22] Christopher David: Well,
[42:22] Christopher David: that's a different error.
[42:26] Christopher David: Can I just omit that?
[42:30] Christopher David: File is empty.
[42:32] Christopher David: Okay.
[42:34] Christopher David: That's a better error,
[42:36] Christopher David: I think. I mean, unless this is just failing.
[42:39] Christopher David: Okay, let's try with an actual file.
[43:13] Christopher David: I don't know what that is,
[43:14] Christopher David: but let's try that.
[43:20] Christopher David: That doesn't exist.
[43:25] Christopher David: Storage,
[43:29] Christopher David: no,
[43:29] Christopher David: not storage,
[43:30] Christopher David: app public.
[43:31] Christopher David: I didn't say that.
[43:33] Christopher David: Storage,
[43:33] Christopher David: app uploads.
[43:46] Christopher David: response status empty what the hell is that well we got something to have something happened let's see how
[44:05] Christopher David: do we see what's here 38kb what did we upload
[44:16] Christopher David: Okay, we uploaded this paper,
[44:17] Christopher David: a soft bot-based interface to the internet.
[44:20] Christopher David: Just some paper I saw on Twitter.
[44:23] Christopher David: Now,
[44:32] Christopher David: what is a soft bot?
[44:38] Christopher David: A softbot is an AI agent that uses planning to achieve goals in a flexible manner,
[44:45] Christopher David: adapting to changes in the system environment.
[44:48] Christopher David: Unlike standard programs,
[44:49] Christopher David: softbots automatically synthesize and execute plans to handle complex combinations of goals.
[44:54] Christopher David: This is cool. I saved this because someone on Twitter was just like, here's a precursor to the idea of AI agents written in 1994.
[45:01] Christopher David: It's like, not cool.
[45:02] Christopher David: We'll probably dig into that.
[45:06] Christopher David: But the good news is that our
[45:13] Christopher David: upload worked and so now to get our test to hopefully this test passes.
[45:21] Christopher David: Let's upload it again,
[45:23] Christopher David: but upload it to a different.
[45:39] Christopher David: Aha!
[45:44] Christopher David: Okay,
[45:44] Christopher David: it can't upload file to Corpus.
[45:57] Christopher David: That's pretty cool.
[46:04] Christopher David: And then usually if there's like a heavy duty...
[46:08] Christopher David: tests that interact with third parties we can put them in a special group that gets excluded most times that we run the test so we don't have to like create corpuses over and over and over we just test it when we specifically want to test that integration but okay what did we do we built a service to easily interact with Vektara in the ways that we need to for authentication
[46:38] Christopher David: For, yeah,
[46:41] Christopher David: authorization,
[46:42] Christopher David: getting the JWT token,
[46:43] Christopher David: creating a corpus, and then uploading a document to the corpus.
[46:46] Christopher David: The next relevant thing,
[46:48] Christopher David: the only other really relevant thing that we need is the querying.
[46:57] Christopher David: So, this is the meat of what we want.
[47:04] Christopher David: Query is a corpus.
[47:08] Christopher David: So,
[47:12] Christopher David: now let's please write one more function that calls Query on a corpus.
[47:22] Christopher David: Here's the docs.
[47:30] Christopher David: Can Query Corpus.
[48:19] Christopher David: Query corpus number four with the
[48:27] Christopher David: what is a softbot.
[48:31] Christopher David: And then for now in the query we're going to die and dump the response body.
[48:49] Christopher David: Oh, that was fast.
[48:52] Christopher David: The internet softbots software robots are fully implemented.
[49:02] Christopher David: Can query corpus.
[49:05] Christopher David: How fast was that? We did that in two minutes.
[49:08] Christopher David: Chat GPT,
[49:09] Christopher David: good job.
[49:10] Christopher David: You came through. Thank you very much.
[49:16] Christopher David: Too bad we're coming to smash you.
[49:18] Christopher David: replace you improve upon you this was nice this was nice can
[49:27] Christopher David: query corpus so so
[49:41] Christopher David: we built a Victoria service do I want to like fully hook it up right now
[50:02] Christopher David: Let's just think about what we're going to do next.
[50:05] Christopher David: So in File Controller,
[50:07] Christopher David: let's just see if we can get this to work. And now the Storage Put File.
[50:18] Christopher David: Create an uploaded file.
[50:21] Christopher David: I don't know how that relates.
[50:23] Christopher David: Let's see if Copilot knows.
[50:33] Christopher David: Do you think this will work?
[50:39] Christopher David: We need to tell it the corpus number.
[50:50] Christopher David: Really, we should create a new corpus first and get the ID.
[50:55] Christopher David: But for now, let's just try uploading.
[50:59] Christopher David: Do I have an empty corpus in here?
[51:03] Christopher David: Let's do
[51:06] Christopher David: corpus number six, 'cause it has no documents in it.
[51:16] Christopher David: We may later want to push this into a queue so it happens in the background without waiting, tying up the HTTP request. But this is fine for now.
[51:26] Christopher David: Uh,
[51:29] Christopher David: is that the right syntax? Looks like it is.
[51:39] Christopher David: Okay.
[51:47] Christopher David: Let's see if we can do it.
[52:02] Christopher David: First of all,
[52:07] Christopher David: upload file test, this now
[52:16] Christopher David: does the full cycle for us. So I guess we should first see if this actually
[52:21] Christopher David: Ah, Vektara not found. That would be helpful if I actually imported it.
[52:39] Christopher David: Our test passed,
[52:40] Christopher David: but
[52:46] Christopher David: did it upload successfully?
[52:50] Christopher David: Oh, it probably would not have because it was a mocked file.
[53:02] Christopher David: What I can do to avoid even trying to do that.
[53:08] Christopher David: We already don't, we skipped the validation if we're going to test,
[53:11] Christopher David: and we should just maybe just skip this upload if we are in a test.
[53:20] Christopher David: Okay.
[53:23] Christopher David: So it's faster because it's not trying to do that.
[53:25] Christopher David: Alright,
[53:25] Christopher David: so when we want to test the Vectara piece of it, we'll just test the service.
[53:35] Christopher David: Like we could separately do a different test that hit that end point with not this file, but with what, but just,
[53:41] Christopher David: you know, that's
[53:46] Christopher David: good for now.
[53:48] Christopher David: So let's go back and just test it from the interface.
[53:54] Christopher David: See what's cooking.
[54:17] Christopher David: Where's my corpus?
[54:24] Christopher David: Computed! It uploaded!
[54:30] Christopher David: We are uploading documents from our
[54:39] Christopher David: local device up to the top.
[54:41] Christopher David: the test corpus
[55:02] Christopher David: And I can talk to it. And this is the thing that we're gonna be next pulling into our interface. But what is a softbox?
[55:23] Christopher David: Define AI agent.
[55:50] Christopher David: Can.
[55:51] Christopher David: SoftBots search the internet and scrape data I want it to get.
[56:03] Christopher David: SoftBots are intelligent personal assistants that can search the internet and scrape data based on high-level requests.
[56:08] Christopher David: They use search, inference,
[56:10] Christopher David: and knowledge to determine how to satisfy their requests.
[56:11] Christopher David: These SoftBots are capable of handling goals specified in an expressive subset of first-order logic.
[56:16] Christopher David: They can tolerate and recover from ambiguity,
[56:18] Christopher David: omissions,
[56:19] Christopher David: and errors in human requests.
[56:20] Christopher David: The softbots can also disambiguate requests and estimate the cost of executing a plan.
[56:25] Christopher David: They provide an integrated and expressive interface to the internet,
[56:27] Christopher David: dynamically choosing which facilities to invoke and in what sequence.
[56:31] Christopher David: Overall,
[56:31] Christopher David: softbots enable users to provide partial specifications of the desired goals,
[56:34] Christopher David: and the softbot plans and subgoals accordingly.
[56:37] Christopher David: That was written in 1994,
[56:38] Christopher David: so we should read that paper.
[56:39] Christopher David: I'm curious.
[56:40] Christopher David: Okay,
[56:41] Christopher David: so that's a good stopping point here.
[56:42] Christopher David: So we have built a service for interacting with the third-party service that we're using for the RAG, Retrieval Augmented Generation.
[56:54] Christopher David: For the uploaded PDFs called Vectara, we have a service with functions for getting the JWT token to authorize to create a corpus.
[57:01] Christopher David: Like a little...
[57:02] Christopher David: repository of documents.
[57:04] Christopher David: It'll be one repository of documents per agent,
[57:11] Christopher David: but conceivably you could have multiple agents share your same corpus, or then share that corpus with other people.
[57:19] Christopher David: And upload the document to Vectora and query it.
[57:25] Christopher David: So we have all of this working in our Vectora test.
[57:34] Christopher David: The only thing so far that we have connected to our UI,
[57:39] Christopher David: let's make sure that test passes. It's doing all of the things.
[57:44] Christopher David: Boom,
[57:44] Christopher David: our test passed.
[57:46] Christopher David: The only thing that we so far have connected to our UI is the uploads of PDF.
[57:53] Christopher David: And the one that I was just chatting with is the PDF that I just uploaded from here.
[58:00] Christopher David: I wonder what happens when I upload the same PDF again.
[58:05] Christopher David: Um, in the next video,
[58:08] Christopher David: we will connect the chat to the query.
[58:14] Christopher David: So we're just going to query the chat.
[58:20] Christopher David: We're going to put this there.
[58:24] Christopher David: And then we'll have like a feature completed.
[58:28] Christopher David: We'll do that.
[58:31] Christopher David: probably this weekend sometime or i might take the weekend off so good week and i have to say after that dev day thing on monday it seemed like open ai was going to be this like runaway freight train invincible and no
[58:52] Christopher David: they released a whole bunch of broken features
[58:59] Christopher David: We shipped image generation today,
[59:00] Christopher David: by the way, like good job,
[59:03] Christopher David: Eric,
[59:03] Christopher David: and good job, Connor,
[59:05] Christopher David: who did a bunch of that work,
[59:06] Christopher David: too.
[59:10] Christopher David: Yeah,
[59:10] Christopher David: like OpenAI has just been like leaking data,
[59:13] Christopher David: which I confirm by being able to download the data that someone put into their agent.
[59:18] Christopher David: So we put up made a little image for it and blasted that out.
[59:23] Christopher David: Ninety eight thousand views not bad.
[59:29] Christopher David: So they've released a bunch of features that just don't work very well.
[01:00:01] Christopher David: So anyway,
[01:00:01] Christopher David: we have a huge opening to actually deliver working agents that don't leak people's data all over the place.
[01:00:10] Christopher David: And I'm excited that we're like a day or two away from having something that works to do some really simple interaction that we can then start to compose. You have your agent with your document that you're chatting with.
[01:00:30] Christopher David: That it's from there one very simple step to have that be able to interact with other agents that you make,
[01:00:36] Christopher David: agents
[01:00:39] Christopher David: other people make,
[01:00:40] Christopher David: connect
[01:00:43] Christopher David: into third-party integrations like GitHub,
[01:00:46] Christopher David: you
[01:00:50] Christopher David: being able to combine your knowledge with another agent.
[01:00:56] Christopher David: You being able to make your corpus and your knowledge base available to other people and other agents for a fee.
[01:01:04] Christopher David: You collected some data set that you dump a bunch of PDFs into that you want to charge for access to.
[01:01:12] Christopher David: There's so many things that we can do with this.
[01:01:15] Christopher David: And very simple building blocks that can be composed in different ways is how we're going to approach this.
[01:01:22] Christopher David: So, thanks for following along,
[01:01:24] Christopher David: and we'll get this nice and solid and rolled out early next week.
[01:01:33] Christopher David: See you soon.