Linux API



Complete documentation for the LumenVox Speech Engine and API is available in our online help file


Total Time:
25-50 Minutes

Get Started – Linux API

Please note: these instructions were written for LumenVox 8.0 and are outdated for LumenVox 8.5 and newer. We are working on updating them and apologize for the inconvenience. In the meantime, please see our Engine help file for complete up–to–date instructions.

If you're developing a custom application with the LumenVox Speech Engine or integrating it into your telephony platform, you'll want to take advantage of our published API.

This page describes how to install our software on Linux and then how to build and run a simple C++ application that uses our API (see also our instructions on doing this on Windows). By the time you're done — less than an hour's work — you will have a working application.

These instructions are written for Fedora Core 6, but past the initial installation, they will be largely the same for any Linux distribution. See our Engine installation guide for detailed instructions on a variety of distributions.

Want proof that it's really this fast?

Watch a timed video of the process, which you can use as a visual aide.

Play Video

Download and Install LumenVox

5–15 Minutes

  1. The easiest way to get the LumenVox speech recognition software is to set up Fedora Core to use YUM to download and install it. First, download our GPG key from and copy it into /etc/pki/rpm-gpg/.
  2. Create a file called LumenVox.repo in /etc/yum.repos.d/.
  3. Edit that file and enter the following information:
    name=LumenVox Products for Fedora Core $releasever - $basearch
  4. Save and close the file.
  5. From the command line, type yum install LumenVoxLicenseServer to download and install the License Server.
  6. Do the same thing for the Speech Engine: yum install LumenVoxSRE. It's a big file, so it may take a few minutes to download.
  7. Once it has installed, logout of your system and log back in.

Installing a License

5–10 Minutes

  1. The first thing you need to do is generate a file called Info.bts that will save some information about your system. Go to the directory /opt/lumenvox/licenseserver/bin/ and type ./getlvsystem_info to generate the file (it is put in the same directory).
  2. Open a Web browser and go to and log in with your username and password (email us if you've misplaced it or didn't receive it).
  3. Go to your Account Information and find your deployment (if you just have one license it will be the only deployment you have). Click License Upload. Deployments
  4. In the License Upload screen, click Browse, select your Info.bts file, and upload it.
  5. Go back to your account screen and find that deployment — the License Upload link has turned into License Download. Click it and save the LicenseXXXX.bts (XXXX is a 4–digit number) file to /opt/lumenvox/licenseserver/bin/.
  6. Go to /opt/lumenvox/licenseserver/bin/ and type
    ./license_mgr –m /opt/lumenvox/licenseserver/bin/LicenseXXXX.bts (be sure and replace XXXX with your 4–digit number).

Verify Installation

3–5 Minutes

  1. First, ensure the License Server and Engine daemons are running. Type ps –el | grep LVSRE_SERVER to make sure that LVSRE_SERVER is running.
  2. For the License Server, do ps –el | grep licenseserver.
  3. You will want the GNU toolchain (make, gcc, etc.) installed in order to build and run our example C++ application.
  4. Navigate to the /opt/lumenvox/engine/examples/ directory, where you will find our example program called example.cpp.
  5. You can build the application by typing make example.
  6. After the program has compiled, you can execute by typing ./example and you should get back the following loop:
    count=0, decode returns 10
    Interpretation 1:
  7. You can end the program by pressing CTRL+C.

Modifying example.cpp

10–20 Minutes

  1. In addition to verifying that the Engine is installed correctly, the example application provides a simple, working program for developers to build upon. It takes a pre–recorded bit of audio (by default the 8587070707.pcm file), compares it to a specified grammar (the ABNFDigits.gram file) and then provides the interpretation (by default a digit string).
  2. You can easily modify the program to recognize other audio files or use different grammars. As an example, we will modify the program to decode the utterance "Yes" using our Boolean grammar (meaning it will return "true" for such an utterance).
  3. The first thing you need to do is to record yourself saying "Yes" in the proper format. The Speech Engine's internal audio format is mono, 8–KHz, 8–bit, header less (raw) u–Law, the standard telephony format in the United States. Using a free program like Audacity ( you can easily record in this format.
  4. Open up Audacity and select Edit > Preferences. Click the File Formats tab and choose "Other‚?¶" for the Uncompressed Export Format. Audacity Preferences
  5. Select "RAW (header–less)" as the header type and "U–Law" as the encoding. File Format
  6. Click OK and then click the Quality tab. Set the Default Sample Rate to 8000 Hz.
  7. Close the preference boxes and record a new file of yourself saying "Yes."
  8. Choose File > Export as Raw‚?¶ and save the file in your /opt/lumenvox/engine/example/ directory as yes.raw.
  9. All you need to do now is to change the example code to use your newly recorded sound file and the Boolean grammar. Open example.cpp and change the line:
    std::string FileName = "8587070707.pcm";
    To read:
    std::string FileName = "yes.raw";
  10. Since you have changed the audio type from the included PCM file to use U–Law, you will need to uncomment the following line:
    //SOUND_FORMAT audio_format = ULAW_8KHZ;
    And comment out this line: 
    SOUND_FORMAT audio_format = PCM_8KHZ;
  11. To switch grammars, modify the line:
    std::string grammar_fn = ABNFDigits.gram";
    To read:
    std::string grammar_fn = "/opt/lumenvox/engine/Lang/
  12. Close and save the file. Delete the old executable by typing make clean and then rebuild the project by typing make example. You can now run the new program by typing ./example and you should get the following loop:
    count=0, decode returns 10
    Interpretation 1:


Congratulations! You are now getting back results using your own voice. You can now try other audio files and grammars (look at /opt/lumenvox/engine/Lang/BuiltinGrammars/ for more built grammars).

© 2016 LumenVox, LLC. All rights reserved.